This function needs to check the list has entries before traversing it. Fix this bug.

Signed-off-by: Simon Glass sjg@chromium.org ---

Changes in v2: - Correct the return code to avoid a test failure

drivers/core/uclass.c | 2 ++ 1 file changed, 2 insertions(+)

diff --git a/drivers/core/uclass.c b/drivers/core/uclass.c index aba9880..ffe6995 100644 --- a/drivers/core/uclass.c +++ b/drivers/core/uclass.c @@ -153,6 +153,8 @@ int uclass_find_device(enum uclass_id id, int index, struct udevice **devp) ret = uclass_get(id, &uc); if (ret) return ret; + if (list_empty(&uc->dev_head)) + return -ENODEV;

list_for_each_entry(dev, &uc->dev_head, uclass_node) { if (!index--) {

When running U-Boot as an EFI application we cannot relocate since we do not have relocation information. U-Boot has already been relocated to a suitable address.

Add a global_data flag to control skipping relocation.

Signed-off-by: Simon Glass sjg@chromium.org ---

Changes in v2: None

common/board_f.c | 7 +++++++ include/asm-generic/global_data.h | 1 + 2 files changed, 8 insertions(+)

diff --git a/common/board_f.c b/common/board_f.c index 21be26f..5e09c5f 100644 --- a/common/board_f.c +++ b/common/board_f.c @@ -664,6 +664,11 @@ static int reloc_fdt(void)

static int setup_reloc(void) { + if (gd->flags & GD_FLG_SKIP_RELOC) { + debug("Skipping relocation due to flag\n"); + return 0; + } + #ifdef CONFIG_SYS_TEXT_BASE gd->reloc_off = gd->relocaddr - CONFIG_SYS_TEXT_BASE; #ifdef CONFIG_M68K @@ -689,6 +694,8 @@ static int setup_reloc(void)

static int jump_to_copy(void) { + if (gd->flags & GD_FLG_SKIP_RELOC) + return 0; /* * x86 is special, but in a nice way. It uses a trampoline which * enables the dcache if possible. diff --git a/include/asm-generic/global_data.h b/include/asm-generic/global_data.h index 7ef3e25..cb2ec08 100644 --- a/include/asm-generic/global_data.h +++ b/include/asm-generic/global_data.h @@ -117,5 +117,6 @@ typedef struct global_data { #define GD_FLG_SERIAL_READY 0x00100 /* Pre-reloc serial console ready */ #define GD_FLG_FULL_MALLOC_INIT 0x00200 /* Full malloc() is ready */ #define GD_FLG_SPL_INIT 0x00400 /* spl_init() has been called */ +#define GD_FLG_SKIP_RELOC 0x00800 /* Don't relocate */

#endif /* __ASM_GENERIC_GBL_DATA_H */

This is currently done for all targets, since 0xff is the default erased value for most flash devices. In some cases this is not what we want (e.g. for EFI images) so provide a command to do a vanilla objcopy.

Signed-off-by: Simon Glass sjg@chromium.org Reviewed-by: Bin Meng bmeng.cn@gmail.com ---

Changes in v2: None

Makefile | 8 +++++++- config.mk | 2 -- 2 files changed, 7 insertions(+), 3 deletions(-)

diff --git a/Makefile b/Makefile index 394ed09..2a3119e 100644 --- a/Makefile +++ b/Makefile @@ -776,8 +776,14 @@ ifneq ($(CONFIG_SYS_TEXT_BASE),) LDFLAGS_u-boot += -Ttext $(CONFIG_SYS_TEXT_BASE) endif

+# Normally we fill empty space with 0xff quiet_cmd_objcopy = OBJCOPY $@ -cmd_objcopy = $(OBJCOPY) $(OBJCOPYFLAGS) $(OBJCOPYFLAGS_$(@F)) $< $@ +cmd_objcopy = $(OBJCOPY) --gap-fill=0xff $(OBJCOPYFLAGS) \ + $(OBJCOPYFLAGS_$(@F)) $< $@ + +# Provide a version which does not do this, for use by EFI +quiet_cmd_zobjcopy = OBJCOPY $@ +cmd_zobjcopy = $(OBJCOPY) $(OBJCOPYFLAGS) $(OBJCOPYFLAGS_$(@F)) $< $@

quiet_cmd_mkimage = MKIMAGE $@ cmd_mkimage = $(objtree)/tools/mkimage $(MKIMAGEFLAGS_$(@F)) -d $< $@ \ diff --git a/config.mk b/config.mk index 6282919..b77d589 100644 --- a/config.mk +++ b/config.mk @@ -73,8 +73,6 @@ endif

RELFLAGS := $(PLATFORM_RELFLAGS)

-OBJCOPYFLAGS += --gap-fill=0xff - PLATFORM_CPPFLAGS += $(RELFLAGS) PLATFORM_CPPFLAGS += -pipe

These will be used for efi.h both for U-Boot running as an EFI application and as a payload. They come from Linux 4.1.

Signed-off-by: Simon Glass sjg@chromium.org ---

Changes in v2: - Fix _aligned() typo

include/linux/types.h | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/include/linux/types.h b/include/linux/types.h index c9a8d9a..6f75be4 100644 --- a/include/linux/types.h +++ b/include/linux/types.h @@ -113,6 +113,11 @@ typedef __s64 int64_t;

#endif /* __KERNEL_STRICT_NAMES */

+/* this is a special 64bit data type that is 8-byte aligned */ +#define aligned_u64 __u64 __aligned(8) +#define aligned_be64 __be64 __aligned(8) +#define aligned_le64 __le64 __aligned(8) + #if defined(CONFIG_USE_STDINT) && defined(__INT64_TYPE__) typedef __UINT64_TYPE__ uint64_t; typedef __UINT64_TYPE__ u_int64_t; @@ -145,7 +150,6 @@ typedef __u64 __bitwise __be64; typedef __u16 __bitwise __sum16; typedef __u32 __bitwise __wsum;

- typedef unsigned __bitwise__ gfp_t;

struct ustat {

These flags now overlap some global ones. Adjust the x86-specific flags to avoid this. Since this requires a change to the start.S code, add a way for tools to find the 32-bit cold reset entry point. Previously this was at a fixed offset.

Signed-off-by: Simon Glass sjg@chromium.org ---

Changes in v2: - Add a marker for the cold reset entry point - Use the now-defined top 16-bits of the global_data flags

arch/x86/cpu/start.S | 8 ++++++-- arch/x86/include/asm/global_data.h | 8 ++++---- 2 files changed, 10 insertions(+), 6 deletions(-)

diff --git a/arch/x86/cpu/start.S b/arch/x86/cpu/start.S index 7ef8b88..9b2584d 100644 --- a/arch/x86/cpu/start.S +++ b/arch/x86/cpu/start.S @@ -41,14 +41,18 @@ _x86boot_start: wbinvd

/* Tell 32-bit code it is being entered from an in-RAM copy */ - movw $GD_FLG_WARM_BOOT, %bx + movl $GD_FLG_WARM_BOOT, %ebx jmp 1f + + /* Add a way for tools to discover the _start entry point */ + .align 4 + .long 0x12345678 _start: /* * This is the 32-bit cold-reset entry point, coming from start16. * Set %bx to 0 to indicate this. */ - movw $GD_FLG_COLD_BOOT, %bx + movl $GD_FLG_COLD_BOOT, %ebx 1: /* Save BIST */ movl %eax, %ebp diff --git a/arch/x86/include/asm/global_data.h b/arch/x86/include/asm/global_data.h index 4d9eac6..3db9a4c 100644 --- a/arch/x86/include/asm/global_data.h +++ b/arch/x86/include/asm/global_data.h @@ -87,14 +87,14 @@ static inline __attribute__((no_instrument_function)) gd_t *get_fs_gd_ptr(void)

#define gd get_fs_gd_ptr()

+#define DECLARE_GLOBAL_DATA_PTR + #endif

/* * Our private Global Data Flags */ -#define GD_FLG_COLD_BOOT 0x00100 /* Cold Boot */ -#define GD_FLG_WARM_BOOT 0x00200 /* Warm Boot */ - -#define DECLARE_GLOBAL_DATA_PTR +#define GD_FLG_COLD_BOOT 0x10000 /* Cold Boot */ +#define GD_FLG_WARM_BOOT 0x20000 /* Warm Boot */

#endif /* __ASM_GBL_DATA_H */

This file does not need its own way of doing debug(). Clean it up to use the new way.

Signed-off-by: Simon Glass sjg@chromium.org Acked-by: Pavel Machek pavel@denx.de Reviewed-by: Bin Meng bmeng.cn@gmail.com ---

Changes in v2: None

drivers/pci/pci_auto.c | 48 +++++++++++++++++++++++------------------------- 1 file changed, 23 insertions(+), 25 deletions(-)

diff --git a/drivers/pci/pci_auto.c b/drivers/pci/pci_auto.c index a7af8cb..7ff282b 100644 --- a/drivers/pci/pci_auto.c +++ b/drivers/pci/pci_auto.c @@ -14,12 +14,6 @@ #include <errno.h> #include <pci.h>

-#ifdef DEBUG -#define DEBUGF(x...) printf(x) -#else -#define DEBUGF(x...) -#endif /* DEBUG */ - /* the user can define CONFIG_SYS_PCI_CACHE_LINE_SIZE to avoid problems */ #ifndef CONFIG_SYS_PCI_CACHE_LINE_SIZE #define CONFIG_SYS_PCI_CACHE_LINE_SIZE 8 @@ -50,20 +44,21 @@ int pciauto_region_allocate(struct pci_region *res, pci_size_t size, pci_addr_t addr;

if (!res) { - DEBUGF("No resource"); + debug("No resource"); goto error; }

addr = ((res->bus_lower - 1) | (size - 1)) + 1;

if (addr - res->bus_start + size > res->size) { - DEBUGF("No room in resource"); + debug("No room in resource"); goto error; }

res->bus_lower = addr + size;

- DEBUGF("address=0x%llx bus_lower=0x%llx", (u64)addr, (u64)res->bus_lower); + debug("address=0x%llx bus_lower=0x%llx", (unsigned long long)addr, + (unsigned long long)res->bus_lower);

*bar = addr; return 0; @@ -122,7 +117,8 @@ void pciauto_setup_device(struct pci_controller *hose, bar_res = io; #endif

- DEBUGF("PCI Autoconfig: BAR %d, I/O, size=0x%llx, ", bar_nr, (u64)bar_size); + debug("PCI Autoconfig: BAR %d, I/O, size=0x%llx, ", + bar_nr, (unsigned long long)bar_size); } else { if ((bar_response & PCI_BASE_ADDRESS_MEM_TYPE_MASK) == PCI_BASE_ADDRESS_MEM_TYPE_64) { @@ -152,7 +148,8 @@ void pciauto_setup_device(struct pci_controller *hose, bar_res = mem; #endif

- DEBUGF("PCI Autoconfig: BAR %d, Mem, size=0x%llx, ", bar_nr, (u64)bar_size); + debug("PCI Autoconfig: BAR %d, Mem, size=0x%llx, ", + bar_nr, (unsigned long long)bar_size); }

#ifndef CONFIG_PCI_ENUM_ONLY @@ -179,7 +176,7 @@ void pciauto_setup_device(struct pci_controller *hose, cmdstat |= (bar_response & PCI_BASE_ADDRESS_SPACE) ? PCI_COMMAND_IO : PCI_COMMAND_MEMORY;

- DEBUGF("\n"); + debug("\n");

bar_nr++; } @@ -193,14 +190,15 @@ void pciauto_setup_device(struct pci_controller *hose, pci_hose_read_config_dword(hose, dev, rom_addr, &bar_response); if (bar_response) { bar_size = -(bar_response & ~1); - DEBUGF("PCI Autoconfig: ROM, size=%#x, ", bar_size); + debug("PCI Autoconfig: ROM, size=%#x, ", + (unsigned int)bar_size); if (pciauto_region_allocate(mem, bar_size, &bar_value) == 0) { pci_hose_write_config_dword(hose, dev, rom_addr, bar_value); } cmdstat |= PCI_COMMAND_MEMORY; - DEBUGF("\n"); + debug("\n"); } }

@@ -411,7 +409,7 @@ void pciauto_config_init(struct pci_controller *hose) if (hose->pci_mem) { pciauto_region_init(hose->pci_mem);

- DEBUGF("PCI Autoconfig: Bus Memory region: [0x%llx-0x%llx],\n" + debug("PCI Autoconfig: Bus Memory region: [0x%llx-0x%llx],\n" "\t\tPhysical Memory [%llx-%llxx]\n", (u64)hose->pci_mem->bus_start, (u64)(hose->pci_mem->bus_start + hose->pci_mem->size - 1), @@ -422,7 +420,7 @@ void pciauto_config_init(struct pci_controller *hose) if (hose->pci_prefetch) { pciauto_region_init(hose->pci_prefetch);

- DEBUGF("PCI Autoconfig: Bus Prefetchable Mem: [0x%llx-0x%llx],\n" + debug("PCI Autoconfig: Bus Prefetchable Mem: [0x%llx-0x%llx],\n" "\t\tPhysical Memory [%llx-%llx]\n", (u64)hose->pci_prefetch->bus_start, (u64)(hose->pci_prefetch->bus_start + @@ -435,7 +433,7 @@ void pciauto_config_init(struct pci_controller *hose) if (hose->pci_io) { pciauto_region_init(hose->pci_io);

- DEBUGF("PCI Autoconfig: Bus I/O region: [0x%llx-0x%llx],\n" + debug("PCI Autoconfig: Bus I/O region: [0x%llx-0x%llx],\n" "\t\tPhysical Memory: [%llx-%llx]\n", (u64)hose->pci_io->bus_start, (u64)(hose->pci_io->bus_start + hose->pci_io->size - 1), @@ -475,8 +473,8 @@ int pciauto_config_device(struct pci_controller *hose, pci_dev_t dev)

switch (class) { case PCI_CLASS_BRIDGE_PCI: - DEBUGF("PCI Autoconfig: Found P2P bridge, device %d\n", - PCI_DEV(dev)); + debug("PCI Autoconfig: Found P2P bridge, device %d\n", + PCI_DEV(dev));

pciauto_setup_device(hose, dev, 2, pci_mem, pci_prefetch, pci_io); @@ -512,8 +510,8 @@ int pciauto_config_device(struct pci_controller *hose, pci_dev_t dev) pciauto_setup_device(hose, dev, 0, pci_mem, pci_prefetch, pci_io);

- DEBUGF("PCI Autoconfig: Found P2CardBus bridge, device %d\n", - PCI_DEV(dev)); + debug("PCI Autoconfig: Found P2CardBus bridge, device %d\n", + PCI_DEV(dev));

#ifndef CONFIG_DM_PCI hose->current_busno++; @@ -522,8 +520,8 @@ int pciauto_config_device(struct pci_controller *hose, pci_dev_t dev)

#if defined(CONFIG_PCIAUTO_SKIP_HOST_BRIDGE) case PCI_CLASS_BRIDGE_OTHER: - DEBUGF("PCI Autoconfig: Skipping bridge device %d\n", - PCI_DEV(dev)); + debug("PCI Autoconfig: Skipping bridge device %d\n", + PCI_DEV(dev)); break; #endif #if defined(CONFIG_MPC834x) && !defined(CONFIG_VME8349) @@ -534,14 +532,14 @@ int pciauto_config_device(struct pci_controller *hose, pci_dev_t dev) * device claiming resources io/mem/irq.. we only allow for * the PIMMR window to be allocated (BAR0 - 1MB size) */ - DEBUGF("PCI Autoconfig: Broken bridge found, only minimal config\n"); + debug("PCI Autoconfig: Broken bridge found, only minimal config\n"); pciauto_setup_device(hose, dev, 0, hose->pci_mem, hose->pci_prefetch, hose->pci_io); break; #endif

case PCI_CLASS_PROCESSOR_POWERPC: /* an agent or end-point */ - DEBUGF("PCI AutoConfig: Found PowerPC device\n"); + debug("PCI AutoConfig: Found PowerPC device\n");

default: pciauto_setup_device(hose, dev, 6, pci_mem,

This option is not used by any board but appears to still be useful, at least for testing. With recent commits it does not build, so fix it.

Signed-off-by: Simon Glass sjg@chromium.org ---

Changes in v2: None

drivers/pci/pci_auto.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/drivers/pci/pci_auto.c b/drivers/pci/pci_auto.c index 7ff282b..51d2ac0 100644 --- a/drivers/pci/pci_auto.c +++ b/drivers/pci/pci_auto.c @@ -82,9 +82,9 @@ void pciauto_setup_device(struct pci_controller *hose, pci_size_t bar_size; u16 cmdstat = 0; int bar, bar_nr = 0; +#ifndef CONFIG_PCI_ENUM_ONLY u8 header_type; int rom_addr; -#ifndef CONFIG_PCI_ENUM_ONLY pci_addr_t bar_value; struct pci_region *bar_res; int found_mem64 = 0; @@ -181,6 +181,7 @@ void pciauto_setup_device(struct pci_controller *hose, bar_nr++; }

+#ifndef CONFIG_PCI_ENUM_ONLY /* Configure the expansion ROM address */ pci_hose_read_config_byte(hose, dev, PCI_HEADER_TYPE, &header_type); if (header_type != PCI_HEADER_TYPE_CARDBUS) { @@ -201,6 +202,7 @@ void pciauto_setup_device(struct pci_controller *hose, debug("\n"); } } +#endif

pci_hose_write_config_word(hose, dev, PCI_COMMAND, cmdstat); pci_hose_write_config_byte(hose, dev, PCI_CACHE_LINE_SIZE,

When running as an EFI application, U-Boot must request memory from EFI, and provide access to the boot services U-Boot needs.

Add library code to perform these tasks. This includes efi_main() which is the entry point from EFI. U-Boot is built as a shared library.

Signed-off-by: Simon Glass sjg@chromium.org ---

Changes in v2: - Add a comment as to why we only allocate pages below 4GB - Add a comment as to why we use global_data_ptr - Add comments as to why we need efi_memset(), efi_putc(), efi_puts() - Avoid useless u64 cast on EFI_RUNTIME_SERVICES_SIGNATURE - Drop __packed from struct efi_device_path - Explain in a comment how the debug UART is implemented for the EFI app - Fix 'command problem' typo - it should say 'command prompt' - Fix 'withU-Boot.' typo - Fix a few comment typos - Fix efi_mem_desc_VERSION typo - Fix mention of CHAR16 which should be wchar_t - Fix missing struct comments - Move the 64-bit payload code to a later patch - Rename CONFIG_ARCH_EFI to CONFIG_EFI_APP - Reword the efi_putc() unicode comment to make more sense - Use image_base instead of ImageBase - Use one-line comments when appropriate - Use reserved instead of __reserved in struct efi_boot_services

arch/x86/include/asm/fsp/fsp_hob.h | 59 +----- include/efi.h | 357 +++++++++++++++++++++++++++++++++++++ include/efi_api.h | 244 +++++++++++++++++++++++++ include/part_efi.h | 9 +- lib/Kconfig | 2 + lib/Makefile | 1 + lib/efi/Kconfig | 33 ++++ lib/efi/Makefile | 7 + lib/efi/efi.c | 101 +++++++++++ lib/efi/efi_app.c | 139 +++++++++++++++ 10 files changed, 888 insertions(+), 64 deletions(-) create mode 100644 include/efi.h create mode 100644 include/efi_api.h create mode 100644 lib/efi/Kconfig create mode 100644 lib/efi/Makefile create mode 100644 lib/efi/efi.c create mode 100644 lib/efi/efi_app.c

diff --git a/arch/x86/include/asm/fsp/fsp_hob.h b/arch/x86/include/asm/fsp/fsp_hob.h index 6cca7f5..3fb3546 100644 --- a/arch/x86/include/asm/fsp/fsp_hob.h +++ b/arch/x86/include/asm/fsp/fsp_hob.h @@ -8,6 +8,8 @@ #ifndef __FSP_HOB_H__ #define __FSP_HOB_H__

+#include <efi.h> + /* Type of HOB Header */ #define HOB_TYPE_MEM_ALLOC 0x0002 #define HOB_TYPE_RES_DESC 0x0003 @@ -25,63 +27,6 @@ struct hob_header { u32 reserved; /* always zero */ };

-/* Enumeration of memory types introduced in UEFI */ -enum efi_mem_type { - EFI_RESERVED_MEMORY_TYPE, - /* - * The code portions of a loaded application. - * (Note that UEFI OS loaders are UEFI applications.) - */ - EFI_LOADER_CODE, - /* - * The data portions of a loaded application and - * the default data allocation type used by an application - * to allocate pool memory. - */ - EFI_LOADER_DATA, - /* The code portions of a loaded Boot Services Driver */ - EFI_BOOT_SERVICES_CODE, - /* - * The data portions of a loaded Boot Serves Driver and - * the default data allocation type used by a Boot Services - * Driver to allocate pool memory. - */ - EFI_BOOT_SERVICES_DATA, - /* The code portions of a loaded Runtime Services Driver */ - EFI_RUNTIME_SERVICES_CODE, - /* - * The data portions of a loaded Runtime Services Driver and - * the default data allocation type used by a Runtime Services - * Driver to allocate pool memory. - */ - EFI_RUNTIME_SERVICES_DATA, - /* Free (unallocated) memory */ - EFI_CONVENTIONAL_MEMORY, - /* Memory in which errors have been detected */ - EFI_UNUSABLE_MEMORY, - /* Memory that holds the ACPI tables */ - EFI_ACPI_RECLAIM_MEMORY, - /* Address space reserved for use by the firmware */ - EFI_ACPI_MEMORY_NVS, - /* - * Used by system firmware to request that a memory-mapped IO region - * be mapped by the OS to a virtual address so it can be accessed by - * EFI runtime services. - */ - EFI_MMAP_IO, - /* - * System memory-mapped IO region that is used to translate - * memory cycles to IO cycles by the processor. - */ - EFI_MMAP_IO_PORT, - /* - * Address space reserved by the firmware for code that is - * part of the processor. - */ - EFI_PAL_CODE, - EFI_MAX_MEMORY_TYPE -}; - /* * Describes all memory ranges used during the HOB producer phase that * exist outside the HOB list. This HOB type describes how memory is used, diff --git a/include/efi.h b/include/efi.h new file mode 100644 index 0000000..5d80373 --- /dev/null +++ b/include/efi.h @@ -0,0 +1,357 @@ +/* + * Extensible Firmware Interface + * Based on 'Extensible Firmware Interface Specification' version 0.9, + * April 30, 1999 + * + * Copyright (C) 1999 VA Linux Systems + * Copyright (C) 1999 Walt Drummond drummond@valinux.com + * Copyright (C) 1999, 2002-2003 Hewlett-Packard Co. + * David Mosberger-Tang davidm@hpl.hp.com + * Stephane Eranian eranian@hpl.hp.com + * + * From include/linux/efi.h in kernel 4.1 with some additions/subtractions + */ + +#ifndef _EFI_H +#define _EFI_H + +#include <linux/string.h> +#include <linux/types.h> + +struct efi_device_path; + +#define EFI_SUCCESS 0 +#define EFI_LOAD_ERROR (1 | (1UL << (BITS_PER_LONG - 1))) +#define EFI_INVALID_PARAMETER (2 | (1UL << (BITS_PER_LONG - 1))) +#define EFI_UNSUPPORTED (3 | (1UL << (BITS_PER_LONG - 1))) +#define EFI_BAD_BUFFER_SIZE (4 | (1UL << (BITS_PER_LONG - 1))) +#define EFI_BUFFER_TOO_SMALL (5 | (1UL << (BITS_PER_LONG - 1))) +#define EFI_NOT_READY (6 | (1UL << (BITS_PER_LONG - 1))) +#define EFI_DEVICE_ERROR (7 | (1UL << (BITS_PER_LONG - 1))) +#define EFI_WRITE_PROTECTED (8 | (1UL << (BITS_PER_LONG - 1))) +#define EFI_OUT_OF_RESOURCES (9 | (1UL << (BITS_PER_LONG - 1))) +#define EFI_NOT_FOUND (14 | (1UL << (BITS_PER_LONG - 1))) +#define EFI_SECURITY_VIOLATION (26 | (1UL << (BITS_PER_LONG - 1))) + +typedef unsigned long efi_status_t; +typedef u64 efi_physical_addr_t; +typedef u64 efi_virtual_addr_t; +typedef void *efi_handle_t; + +#define EFI_GUID(a, b, c, d0, d1, d2, d3, d4, d5, d6, d7) \ + ((efi_guid_t) \ + {{ (a) & 0xff, ((a) >> 8) & 0xff, ((a) >> 16) & 0xff, \ + ((a) >> 24) & 0xff, \ + (b) & 0xff, ((b) >> 8) & 0xff, \ + (c) & 0xff, ((c) >> 8) & 0xff, \ + (d0), (d1), (d2), (d3), (d4), (d5), (d6), (d7) } }) + +/* Generic EFI table header */ +struct efi_table_hdr { + u64 signature; + u32 revision; + u32 headersize; + u32 crc32; + u32 reserved; +}; + +/* Enumeration of memory types introduced in UEFI */ +enum efi_mem_type { + EFI_RESERVED_MEMORY_TYPE, + /* + * The code portions of a loaded application. + * (Note that UEFI OS loaders are UEFI applications.) + */ + EFI_LOADER_CODE, + /* + * The data portions of a loaded application and + * the default data allocation type used by an application + * to allocate pool memory. + */ + EFI_LOADER_DATA, + /* The code portions of a loaded Boot Services Driver */ + EFI_BOOT_SERVICES_CODE, + /* + * The data portions of a loaded Boot Serves Driver and + * the default data allocation type used by a Boot Services + * Driver to allocate pool memory. + */ + EFI_BOOT_SERVICES_DATA, + /* The code portions of a loaded Runtime Services Driver */ + EFI_RUNTIME_SERVICES_CODE, + /* + * The data portions of a loaded Runtime Services Driver and + * the default data allocation type used by a Runtime Services + * Driver to allocate pool memory. + */ + EFI_RUNTIME_SERVICES_DATA, + /* Free (unallocated) memory */ + EFI_CONVENTIONAL_MEMORY, + /* Memory in which errors have been detected */ + EFI_UNUSABLE_MEMORY, + /* Memory that holds the ACPI tables */ + EFI_ACPI_RECLAIM_MEMORY, + /* Address space reserved for use by the firmware */ + EFI_ACPI_MEMORY_NVS, + /* + * Used by system firmware to request that a memory-mapped IO region + * be mapped by the OS to a virtual address so it can be accessed by + * EFI runtime services. + */ + EFI_MMAP_IO, + /* + * System memory-mapped IO region that is used to translate + * memory cycles to IO cycles by the processor. + */ + EFI_MMAP_IO_PORT, + /* + * Address space reserved by the firmware for code that is + * part of the processor. + */ + EFI_PAL_CODE, + + EFI_MAX_MEMORY_TYPE, + EFI_TABLE_END, /* For efi_build_mem_table() */ +}; + +/* Attribute values */ +enum { + EFI_MEMORY_UC_SHIFT = 0, /* uncached */ + EFI_MEMORY_WC_SHIFT = 1, /* write-coalescing */ + EFI_MEMORY_WT_SHIFT = 2, /* write-through */ + EFI_MEMORY_WB_SHIFT = 3, /* write-back */ + EFI_MEMORY_UCE_SHIFT = 4, /* uncached, exported */ + EFI_MEMORY_WP_SHIFT = 12, /* write-protect */ + EFI_MEMORY_RP_SHIFT = 13, /* read-protect */ + EFI_MEMORY_XP_SHIFT = 14, /* execute-protect */ + EFI_MEMORY_RUNTIME_SHIFT = 63, /* range requires runtime mapping */ + + EFI_MEMORY_RUNTIME = 1ULL << EFI_MEMORY_RUNTIME_SHIFT, + EFI_MEM_DESC_VERSION = 1, +}; + +#define EFI_PAGE_SHIFT 12 +#define EFI_PAGE_SIZE (1UL << EFI_PAGE_SHIFT) + +struct efi_mem_desc { + u32 type; + u32 reserved; + efi_physical_addr_t physical_start; + efi_virtual_addr_t virtual_start; + u64 num_pages; + u64 attribute; +}; + +/* Allocation types for calls to boottime->allocate_pages*/ +#define EFI_ALLOCATE_ANY_PAGES 0 +#define EFI_ALLOCATE_MAX_ADDRESS 1 +#define EFI_ALLOCATE_ADDRESS 2 +#define EFI_MAX_ALLOCATE_TYPE 3 + +/* Types and defines for Time Services */ +#define EFI_TIME_ADJUST_DAYLIGHT 0x1 +#define EFI_TIME_IN_DAYLIGHT 0x2 +#define EFI_UNSPECIFIED_TIMEZONE 0x07ff + +struct efi_time { + u16 year; + u8 month; + u8 day; + u8 hour; + u8 minute; + u8 second; + u8 pad1; + u32 nanosecond; + s16 timezone; + u8 daylight; + u8 pad2; +}; + +struct efi_time_cap { + u32 resolution; + u32 accuracy; + u8 sets_to_zero; +}; + +enum efi_locate_search_type { + all_handles, + by_register_notify, + by_protocol +}; + +struct efi_open_protocol_info_entry { + efi_handle_t agent_handle; + efi_handle_t controller_handle; + u32 attributes; + u32 open_count; +}; + +enum efi_entry_t { + EFIET_END, /* Signals this is the last (empty) entry */ + EFIET_MEMORY_MAP, + + /* Number of entries */ + EFIET_MEMORY_COUNT, +}; + +#define EFI_TABLE_VERSION 1 + +/** + * struct efi_info_hdr - Header for the EFI info table + * + * @version: EFI_TABLE_VERSION + * @hdr_size: Size of this struct in bytes + * @total_size: Total size of this header plus following data + * @spare: Spare space for expansion + */ +struct efi_info_hdr { + u32 version; + u32 hdr_size; + u32 total_size; + u32 spare[5]; +}; + +/** + * struct efi_entry_hdr - Header for a table entry + * + * @type: enum eft_entry_t + * @size size of entry bytes excluding header and padding + * @addr: address of this entry (0 if it follows the header ) + * @link: size of entry including header and padding + * @spare1: Spare space for expansion + * @spare2: Spare space for expansion + * @ + */ +struct efi_entry_hdr { + u32 type; + u32 size; + u64 addr; + u32 link; + u32 spare1; + u64 spare2; +}; + +/** + * struct efi_entry_memmap - a memory map table passed to U-Boot + * + * @version: EFI's memory map table version + * @desc_size: EFI's size of each memory descriptor + * @spare: Spare space for expansion + * @desc: An array of descriptors, each @desc_size bytes apart + */ +struct efi_entry_memmap { + u32 version; + u32 desc_size; + u64 spare; + struct efi_mem_desc desc[]; +}; + +static inline struct efi_mem_desc *efi_get_next_mem_desc( + struct efi_entry_memmap *map, struct efi_mem_desc *desc) +{ + return (struct efi_mem_desc *)((ulong)desc + map->desc_size); +} + +struct efi_priv { + efi_handle_t parent_image; + struct efi_device_path *device_path; + struct efi_system_table *sys_table; + struct efi_boot_services *boot; + struct efi_runtime_services *run; + bool use_pool_for_malloc; + unsigned long ram_base; + unsigned int image_data_type; + struct efi_info_hdr *info; + unsigned int info_size; + void *next_hdr; +}; + +/* Base address of the EFI image */ +extern char image_base[]; + +/** + * efi_get_sys_table() - Get access to the main EFI system table + * + * @return pointer to EFI system table + */ +struct efi_system_table *efi_get_sys_table(void); + +/** + * efi_get_ram_base() - Find the base of RAM + * + * This is used when U-Boot is built as an EFI application. + * + * @return the base of RAM as known to U-Boot + */ +unsigned long efi_get_ram_base(void); + +/** + * efi_init() - Set up ready for use of EFI boot services + * + * @priv: Pointer to our private EFI structure to fill in + * @banner: Banner to display when starting + * @image: The image handle passed to efi_main() + * @sys_table: The EFI system table pointer passed to efi_main() + */ +int efi_init(struct efi_priv *priv, const char *banner, efi_handle_t image, + struct efi_system_table *sys_table); + +/** + * efi_malloc() - Allocate some memory from EFI + * + * @priv: Pointer to private EFI structure + * @size: Number of bytes to allocate + * @retp: Return EFI status result + * @return pointer to memory allocated, or NULL on error + */ +void *efi_malloc(struct efi_priv *priv, int size, efi_status_t *retp); + +/** + * efi_free() - Free memory allocated from EFI + * + * @priv: Pointer to private EFI structure + * @ptr: Pointer to memory to free + */ +void efi_free(struct efi_priv *priv, void *ptr); + +/** + * efi_puts() - Write out a string to the EFI console + * + * @priv: Pointer to private EFI structure + * @str: String to write (note this is a ASCII, not unicode) + */ +void efi_puts(struct efi_priv *priv, const char *str); + +/** + * efi_putc() - Write out a character to the EFI console + * + * @priv: Pointer to private EFI structure + * @ch: Character to write (note this is not unicode) + */ +void efi_putc(struct efi_priv *priv, const char ch); + +/** + * efi_info_get() - get an entry from an EFI table + * + * @type: Entry type to search for + * @datap: Returns pointer to entry data + * @sizep: Returns pointer to entry size + * @return 0 if OK, -ENODATA if there is no table, -ENOENT if there is no entry + * of the requested type, -EPROTONOSUPPORT if the table has the wrong version + */ +int efi_info_get(enum efi_entry_t type, void **datap, int *sizep); + +/** + * efi_build_mem_table() - make a sorted copy of the memory table + * + * @map: Pointer to EFI memory map table + * @size: Size of table in bytes + * @skip_bs: True to skip boot-time memory and merge it with conventional + * memory. This will significantly reduce the number of table + * entries. + * @return pointer to the new table. It should be freed with free() by the + * caller + */ +void *efi_build_mem_table(struct efi_entry_memmap *map, int size, bool skip_bs); + +#endif /* _LINUX_EFI_H */ diff --git a/include/efi_api.h b/include/efi_api.h new file mode 100644 index 0000000..4fd17d6 --- /dev/null +++ b/include/efi_api.h @@ -0,0 +1,244 @@ +/* + * Extensible Firmware Interface + * Based on 'Extensible Firmware Interface Specification' version 0.9, + * April 30, 1999 + * + * Copyright (C) 1999 VA Linux Systems + * Copyright (C) 1999 Walt Drummond drummond@valinux.com + * Copyright (C) 1999, 2002-2003 Hewlett-Packard Co. + * David Mosberger-Tang davidm@hpl.hp.com + * Stephane Eranian eranian@hpl.hp.com + * + * From include/linux/efi.h in kernel 4.1 with some additions/subtractions + */ + +#ifndef _EFI_API_H +#define _EFI_API_H + +#include <efi.h> + +/* EFI Boot Services table */ +struct efi_boot_services { + struct efi_table_hdr hdr; + void *raise_tpl; + void *restore_tpl; + + efi_status_t (EFIAPI *allocate_pages)(int, int, unsigned long, + efi_physical_addr_t *); + efi_status_t (EFIAPI *free_pages)(efi_physical_addr_t, unsigned long); + efi_status_t (EFIAPI *get_memory_map)(unsigned long *memory_map_size, + struct efi_mem_desc *desc, unsigned long *key, + unsigned long *desc_size, u32 *desc_version); + efi_status_t (EFIAPI *allocate_pool)(int, unsigned long, void **); + efi_status_t (EFIAPI *free_pool)(void *); + + void *create_event; + void *set_timer; + efi_status_t(EFIAPI *wait_for_event)(unsigned long number_of_events, + void *event, unsigned long *index); + void *signal_event; + void *close_event; + void *check_event; + + void *install_protocol_interface; + void *reinstall_protocol_interface; + void *uninstall_protocol_interface; + efi_status_t (EFIAPI *handle_protocol)(efi_handle_t, efi_guid_t *, + void **); + void *reserved; + void *register_protocol_notify; + efi_status_t (EFIAPI *locate_handle)( + enum efi_locate_search_type search_type, + efi_guid_t *protocol, void *search_key, + unsigned long *buffer_size, efi_handle_t *buffer); + efi_status_t (EFIAPI *locate_device_path)(efi_guid_t *protocol, + struct efi_device_path **device_path, + efi_handle_t *device); + void *install_configuration_table; + + efi_status_t (EFIAPI *load_image)(bool boot_policiy, + efi_handle_t parent_image, + struct efi_device_path *file_path, void *source_buffer, + unsigned long source_size, efi_handle_t *image); + efi_status_t (EFIAPI *start_image)(efi_handle_t handle, + unsigned long *exitdata_size, + s16 **exitdata); + efi_status_t (EFIAPI *exit)(efi_handle_t handle, + efi_status_t exit_status, + unsigned long exitdata_size, s16 *exitdata); + void *unload_image; + efi_status_t (EFIAPI *exit_boot_services)(efi_handle_t, unsigned long); + + efi_status_t (EFIAPI *get_next_monotonic_count)(u64 *count); + efi_status_t (EFIAPI *stall)(unsigned long usecs); + void *set_watchdog_timer; + efi_status_t(EFIAPI *connect_controller)(efi_handle_t controller_handle, + efi_handle_t *driver_image_handle, + struct efi_device_path *remaining_device_path, + bool recursive); + void *disconnect_controller; +#define EFI_OPEN_PROTOCOL_BY_HANDLE_PROTOCOL 0x00000001 +#define EFI_OPEN_PROTOCOL_GET_PROTOCOL 0x00000002 +#define EFI_OPEN_PROTOCOL_TEST_PROTOCOL 0x00000004 +#define EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER 0x00000008 +#define EFI_OPEN_PROTOCOL_BY_DRIVER 0x00000010 +#define EFI_OPEN_PROTOCOL_EXCLUSIVE 0x00000020 + efi_status_t (EFIAPI *open_protocol)(efi_handle_t handle, + efi_guid_t *protocol, void **interface, + efi_handle_t agent_handle, + efi_handle_t controller_handle, u32 attributes); + void *close_protocol; + efi_status_t(EFIAPI *open_protocol_information)(efi_handle_t handle, + efi_guid_t *protocol, + struct efi_open_protocol_info_entry **entry_buffer, + unsigned long *entry_count); + efi_status_t (EFIAPI *protocols_per_handle)(efi_handle_t handle, + efi_guid_t ***protocol_buffer, + unsigned long *protocols_buffer_count); + efi_status_t (EFIAPI *locate_handle_buffer) ( + enum efi_locate_search_type search_type, + efi_guid_t *protocol, void *search_key, + unsigned long *no_handles, efi_handle_t **buffer); + void *locate_protocol; + void *install_multiple_protocol_interfaces; + void *uninstall_multiple_protocol_interfaces; + void *calculate_crc32; + void *copy_mem; + void *set_mem; + void *create_event_ex; +}; + +/* Types and defines for EFI ResetSystem */ +enum efi_reset_type { + EFI_RESET_COLD = 0, + EFI_RESET_WARM = 1, + EFI_RESET_SHUTDOWN = 2 +}; + +/* EFI Runtime Services table */ +#define EFI_RUNTIME_SERVICES_SIGNATURE 0x5652453544e5552ULL +#define EFI_RUNTIME_SERVICES_REVISION 0x00010000 + +struct efi_runtime_services { + struct efi_table_hdr hdr; + void *get_time; + void *set_time; + void *get_wakeup_time; + void *set_wakeup_time; + void *set_virtual_address_map; + void *convert_pointer; + efi_status_t (EFIAPI *get_variable)(s16 *variable_name, + efi_guid_t *vendor, u32 *attributes, + unsigned long *data_size, void *data); + efi_status_t (EFIAPI *get_next_variable)( + unsigned long *variable_name_size, + s16 *variable_name, efi_guid_t *vendor); + efi_status_t (EFIAPI *set_variable)(s16 *variable_name, + efi_guid_t *vendor, u32 attributes, + unsigned long data_size, void *data); + void *get_next_high_mono_count; + void (EFIAPI *reset_system)(enum efi_reset_type reset_type, + efi_status_t reset_status, + unsigned long data_size, void *reset_data); + void *update_capsule; + void *query_capsule_caps; + void *query_variable_info; +}; + +/* EFI Configuration Table and GUID definitions */ +#define NULL_GUID \ + EFI_GUID(0x00000000, 0x0000, 0x0000, 0x00, 0x00, \ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00) + +#define LOADED_IMAGE_PROTOCOL_GUID \ + EFI_GUID(0x5b1b31a1, 0x9562, 0x11d2, 0x8e, 0x3f, \ + 0x00, 0xa0, 0xc9, 0x69, 0x72, 0x3b) + +struct efi_system_table { + struct efi_table_hdr hdr; + unsigned long fw_vendor; /* physical addr of wchar_t vendor string */ + u32 fw_revision; + unsigned long con_in_handle; + struct efi_simple_input_interface *con_in; + unsigned long con_out_handle; + struct efi_simple_text_output_protocol *con_out; + unsigned long stderr_handle; + unsigned long std_err; + struct efi_runtime_services *runtime; + struct efi_boot_services *boottime; + unsigned long nr_tables; + unsigned long tables; +}; + +struct efi_loaded_image { + u32 revision; + void *parent_handle; + struct efi_system_table *system_table; + void *device_handle; + void *file_path; + void *reserved; + u32 load_options_size; + void *load_options; + void *image_base; + aligned_u64 image_size; + unsigned int image_code_type; + unsigned int image_data_type; + unsigned long unload; +}; + +struct efi_device_path { + u8 type; + u8 sub_type; + u16 length; +}; + +struct simple_text_output_mode { + s32 max_mode; + s32 mode; + s32 attribute; + s32 cursor_column; + s32 cursor_row; + bool cursor_visible; +}; + +struct efi_simple_text_output_protocol { + void *reset; + efi_status_t (EFIAPI *output_string)( + struct efi_simple_text_output_protocol *this, + const unsigned short *str); + void *test_string; + + efi_status_t(EFIAPI *query_mode)( + struct efi_simple_text_output_protocol *this, + unsigned long mode_number, unsigned long *columns, + unsigned long *rows); + efi_status_t(EFIAPI *set_mode)( + struct efi_simple_text_output_protocol *this, + unsigned long mode_number); + efi_status_t(EFIAPI *set_attribute)( + struct efi_simple_text_output_protocol *this, + unsigned long attribute); + efi_status_t(EFIAPI *clear_screen) ( + struct efi_simple_text_output_protocol *this); + efi_status_t(EFIAPI *set_cursor_position) ( + struct efi_simple_text_output_protocol *this, + unsigned long column, unsigned long row); + efi_status_t(EFIAPI *enable_cursor)(void *, bool enable); + struct simple_text_output_mode *mode; +}; + +struct efi_input_key { + u16 scan_code; + s16 unicode_char; +}; + +struct efi_simple_input_interface { + efi_status_t(EFIAPI *reset)(struct efi_simple_input_interface *this, + bool ExtendedVerification); + efi_status_t(EFIAPI *read_key_stroke)( + struct efi_simple_input_interface *this, + struct efi_input_key *key); + void *wait_for_key; +}; + +#endif diff --git a/include/part_efi.h b/include/part_efi.h index d68ef3b..3012b91 100644 --- a/include/part_efi.h +++ b/include/part_efi.h @@ -18,6 +18,8 @@ #ifndef _DISK_PART_EFI_H #define _DISK_PART_EFI_H

+#include <efi.h> + #define MSDOS_MBR_SIGNATURE 0xAA55 #define EFI_PMBR_OSTYPE_EFI 0xEF #define EFI_PMBR_OSTYPE_EFI_GPT 0xEE @@ -29,13 +31,6 @@ #define GPT_ENTRY_NUMBERS 128 #define GPT_ENTRY_SIZE 128

-#define EFI_GUID(a,b,c,d0,d1,d2,d3,d4,d5,d6,d7) \ - ((efi_guid_t) \ - {{ (a) & 0xff, ((a) >> 8) & 0xff, ((a) >> 16) & 0xff, ((a) >> 24) & 0xff, \ - (b) & 0xff, ((b) >> 8) & 0xff, \ - (c) & 0xff, ((c) >> 8) & 0xff, \ - (d0), (d1), (d2), (d3), (d4), (d5), (d6), (d7) }}) - #define PARTITION_SYSTEM_GUID \ EFI_GUID( 0xC12A7328, 0xF81F, 0x11d2, \ 0xBA, 0x4B, 0x00, 0xA0, 0xC9, 0x3E, 0xC9, 0x3B) diff --git a/lib/Kconfig b/lib/Kconfig index 972ac17..884218a 100644 --- a/lib/Kconfig +++ b/lib/Kconfig @@ -98,4 +98,6 @@ config ERRNO_STR - if errno is null or positive number - a pointer to "Success" message - if errno is negative - a pointer to errno related message

+source lib/efi/Kconfig + endmenu diff --git a/lib/Makefile b/lib/Makefile index fd106b9..db7d980 100644 --- a/lib/Makefile +++ b/lib/Makefile @@ -7,6 +7,7 @@

ifndef CONFIG_SPL_BUILD

+obj-$(CONFIG_EFI) += efi/ obj-$(CONFIG_RSA) += rsa/ obj-$(CONFIG_LZMA) += lzma/ obj-$(CONFIG_LZO) += lzo/ diff --git a/lib/efi/Kconfig b/lib/efi/Kconfig new file mode 100644 index 0000000..b23ba5b --- /dev/null +++ b/lib/efi/Kconfig @@ -0,0 +1,33 @@ +config EFI + bool "Support running U-Boot from EFI" + depends on X86 + 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 X86 && EFI + +config EFI_APP + bool "Support running as an EFI application" + 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_RAM_SIZE + hex "Amount of EFI RAM for U-Boot" + depends on EFI_APP + default 0x2000000 + 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. + +endchoice diff --git a/lib/efi/Makefile b/lib/efi/Makefile new file mode 100644 index 0000000..5ee344c --- /dev/null +++ b/lib/efi/Makefile @@ -0,0 +1,7 @@ +# +# (C) Copyright 2015 Google, Inc +# +# SPDX-License-Identifier: GPL-2.0+ +# + +obj-$(CONFIG_EFI_APP) += efi_app.o efi.o diff --git a/lib/efi/efi.c b/lib/efi/efi.c new file mode 100644 index 0000000..c6454ea --- /dev/null +++ b/lib/efi/efi.c @@ -0,0 +1,101 @@ +/* + * Copyright (c) 2015 Google, Inc + * + * SPDX-License-Identifier: GPL-2.0+ + * + * EFI information obtained here: + * http://wiki.phoenix.com/wiki/index.php/EFI_BOOT_SERVICES + * + * Common EFI functions + */ + +#include <common.h> +#include <debug_uart.h> +#include <errno.h> +#include <linux/err.h> +#include <linux/types.h> +#include <efi.h> +#include <efi_api.h> + +DECLARE_GLOBAL_DATA_PTR; + +/* + * Unfortunately we cannot access any code outside what be build especially + * for the stub. lib/string.c is already being built for the U-Boot payload + * so it using 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 = 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); +} diff --git a/lib/efi/efi_app.c b/lib/efi/efi_app.c new file mode 100644 index 0000000..452ab5d --- /dev/null +++ b/lib/efi/efi_app.c @@ -0,0 +1,139 @@ +/* + * Copyright (c) 2015 Google, Inc + * + * SPDX-License-Identifier: GPL-2.0+ + * + * 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 <common.h> +#include <debug_uart.h> +#include <errno.h> +#include <linux/err.h> +#include <linux/types.h> +#include <efi.h> +#include <efi_api.h> + +DECLARE_GLOBAL_DATA_PTR; + +static struct efi_priv *global_priv; + +struct efi_system_table *efi_get_sys_table(void) +{ + return global_priv->sys_table; +} + +unsigned long efi_get_ram_base(void) +{ + return global_priv->ram_base; +} + +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_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) { + printf("(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 { + priv->ram_base = addr; + } + gd->ram_size = pages << 12; + + return 0; +} + +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; +} + +/** + * 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 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 */ + efi_init(priv, "App", image, sys_table); + + global_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; + } + + printf("starting\n"); + + board_init_f(GD_FLG_SKIP_RELOC); + board_init_r(NULL, 0); + free_memory(priv); + + return EFI_SUCCESS; +} + +void reset_cpu(ulong addr) +{ + struct efi_priv *priv = global_priv; + + free_memory(priv); + printf("U-Boot EFI exiting\n"); + priv->boot->exit(priv->parent_image, EFI_SUCCESS, 0, NULL); +}

With EFI the start address of U-Boot is specified differently. We could consider just setting GD_FLG_RELOC and then setting up reloc_off. But that flag has other implementations and we are not able to use U-Boot relocation which this flag implies.

Instead, just add a special case for EFI.

Signed-off-by: Simon Glass sjg@chromium.org Reviewed-by: Bin Meng bmeng.cn@gmail.com ---

Changes in v2: - Rename CONFIG_ARCH_EFI to CONFIG_EFI_APP - Rename ImageBase to image_base

lib/initcall.c | 4 ++++ 1 file changed, 4 insertions(+)

diff --git a/lib/initcall.c b/lib/initcall.c index 7142744..db7c558 100644 --- a/lib/initcall.c +++ b/lib/initcall.c @@ -6,6 +6,7 @@

#include <common.h> #include <initcall.h> +#include <efi.h>

DECLARE_GLOBAL_DATA_PTR;

@@ -19,6 +20,9 @@ int initcall_run_list(const init_fnc_t init_sequence[])

if (gd->flags & GD_FLG_RELOC) reloc_ofs = gd->reloc_off; +#ifdef CONFIG_EFI_APP + reloc_ofs = (unsigned long)image_base; +#endif debug("initcall: %p", (char *)*init_fnc_ptr - reloc_ofs); if (gd->flags & GD_FLG_RELOC) debug(" (relocated to %p)\n", (char *)*init_fnc_ptr);

Add a serial driver which makes use of EFI's console in/out service.

Signed-off-by: Simon Glass sjg@chromium.org ---

Changes in v2: - Add a comment about special handling for backspace - Add a comment as to why debug_uart_init() is empty - Drop unused DECLARE_GLOBAL_DATA_PTR - Rename CONFIG_ARCH_EFI to CONFIG_EFI_APP - Rename EFI debug UART to EFI_CONSOLE - Replace serial_s5p with serial_efi

drivers/serial/Kconfig | 9 +++ drivers/serial/Makefile | 1 + drivers/serial/serial_efi.c | 157 ++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 167 insertions(+) create mode 100644 drivers/serial/serial_efi.c

diff --git a/drivers/serial/Kconfig b/drivers/serial/Kconfig index 4829284..bfbf58f 100644 --- a/drivers/serial/Kconfig +++ b/drivers/serial/Kconfig @@ -44,6 +44,15 @@ config DEBUG_UART_NS16550 will need to provide parameters to make this work. The driver will be available until the real driver model serial is running.

+config DEBUG_EFI_CONSOLE + bool "EFI" + depends on EFI_APP + help + Select this to enable a debug console which calls back to EFI to + output to the console. This can be useful for early debugging of + U-Boot when running on top of EFI (Extensive Firmware Interface). + This is a type of BIOS used by PCs. + endchoice

config DEBUG_UART_BASE diff --git a/drivers/serial/Makefile b/drivers/serial/Makefile index d183eed..1d1f036 100644 --- a/drivers/serial/Makefile +++ b/drivers/serial/Makefile @@ -21,6 +21,7 @@ obj-$(CONFIG_ALTERA_JTAG_UART) += altera_jtag_uart.o obj-$(CONFIG_ARM_DCC) += arm_dcc.o obj-$(CONFIG_ATMEL_USART) += atmel_usart.o obj-$(CONFIG_DW_SERIAL) += serial_dw.o +obj-$(CONFIG_EFI_APP) += serial_efi.o obj-$(CONFIG_LPC32XX_HSUART) += lpc32xx_hsuart.o obj-$(CONFIG_MCFUART) += mcfuart.o obj-$(CONFIG_OPENCORES_YANU) += opencores_yanu.o diff --git a/drivers/serial/serial_efi.c b/drivers/serial/serial_efi.c new file mode 100644 index 0000000..cf57d89 --- /dev/null +++ b/drivers/serial/serial_efi.c @@ -0,0 +1,157 @@ +/* + * Copyright (c) 2015 Google, Inc + * Written by Simon Glass sjg@chromium.org + * + * SPDX-License-Identifier: GPL-2.0+ + */ + +#include <common.h> +#include <debug_uart.h> +#include <dm.h> +#include <efi.h> +#include <efi_api.h> +#include <errno.h> +#include <fdtdec.h> +#include <linux/compiler.h> +#include <asm/io.h> +#include <serial.h> + +/* Information about the efi console */ +struct serial_efi_priv { + struct efi_simple_input_interface *con_in; + struct efi_simple_text_output_protocol *con_out; + struct efi_input_key key; + bool have_key; +}; + +int serial_efi_setbrg(struct udevice *dev, int baudrate) +{ + return 0; +} + +static int serial_efi_get_key(struct serial_efi_priv *priv) +{ + int ret; + + if (priv->have_key) + return 0; + ret = priv->con_in->read_key_stroke(priv->con_in, &priv->key); + if (ret == EFI_NOT_READY) + return -EAGAIN; + else if (ret != EFI_SUCCESS) + return -EIO; + + priv->have_key = true; + + return 0; +} + +static int serial_efi_getc(struct udevice *dev) +{ + struct serial_efi_priv *priv = dev_get_priv(dev); + int ret, ch; + + ret = serial_efi_get_key(priv); + if (ret) + return ret; + + priv->have_key = false; + ch = priv->key.unicode_char; + + /* + * Unicode char 8 (for backspace) is never returned. Instead we get a + * key scan code of 8. Handle this so that backspace works correctly + * in the U-Boot command line. + */ + if (!ch && priv->key.scan_code == 8) + ch = 8; + debug(" [%x %x %x] ", ch, priv->key.unicode_char, priv->key.scan_code); + + return ch; +} + +static int serial_efi_putc(struct udevice *dev, const char ch) +{ + struct serial_efi_priv *priv = dev_get_priv(dev); + uint16_t ucode[2]; + int ret; + + ucode[0] = ch; + ucode[1] = '\0'; + ret = priv->con_out->output_string(priv->con_out, ucode); + if (ret) + return -EIO; + + return 0; +} + +static int serial_efi_pending(struct udevice *dev, bool input) +{ + struct serial_efi_priv *priv = dev_get_priv(dev); + int ret; + + /* We assume that EFI will stall if its output buffer fills up */ + if (!input) + return 0; + + ret = serial_efi_get_key(priv); + if (ret == -EAGAIN) + return 0; + else if (ret) + return ret; + + return 1; +} + +/* + * There is nothing to init here since the EFI console is already running by + * the time we enter U-Boot. + */ +void debug_uart_init(void) +{ +} + +static inline void _debug_uart_putc(int ch) +{ + struct efi_system_table *sys_table = efi_get_sys_table(); + uint16_t ucode[2]; + + ucode[0] = ch; + ucode[1] = '\0'; + sys_table->con_out->output_string(sys_table->con_out, ucode); +} + +DEBUG_UART_FUNCS + +static int serial_efi_probe(struct udevice *dev) +{ + struct efi_system_table *table = efi_get_sys_table(); + struct serial_efi_priv *priv = dev_get_priv(dev); + + priv->con_in = table->con_in; + priv->con_out = table->con_out; + + return 0; +} + +static const struct dm_serial_ops serial_efi_ops = { + .putc = serial_efi_putc, + .getc = serial_efi_getc, + .pending = serial_efi_pending, + .setbrg = serial_efi_setbrg, +}; + +static const struct udevice_id serial_efi_ids[] = { + { .compatible = "efi,uart" }, + { } +}; + +U_BOOT_DRIVER(serial_efi) = { + .name = "serial_efi", + .id = UCLASS_SERIAL, + .of_match = serial_efi_ids, + .priv_auto_alloc_size = sizeof(struct serial_efi_priv), + .probe = serial_efi_probe, + .ops = &serial_efi_ops, + .flags = DM_FLAG_PRE_RELOC, +};

From: Ben Stoltz stoltz@google.com

When U-Boot runs as an EFI application is does not have a definition of CONFIG_SYS_TEXT_BASE. U-Boot is a relocatable application and the relocation is done by EFI. U-Boot can be loaded at any address.

Ensure that this CONFIG option is not set in this case.

Signed-off-by: Ben Stoltz stoltz@google.com Signed-off-by: Simon Glass sjg@chromium.org Reviewed-by: Bin Meng bmeng.cn@gmail.com ---

Changes in v2: - Rename CONFIG_ARCH_EFI to CONFIG_EFI_APP

Kconfig | 1 + 1 file changed, 1 insertion(+)

diff --git a/Kconfig b/Kconfig index fc69189..05a34f7 100644 --- a/Kconfig +++ b/Kconfig @@ -179,6 +179,7 @@ config SYS_EXTRA_OPTIONS

config SYS_TEXT_BASE depends on SPARC || ARC || X86 || ARCH_UNIPHIER || ARCH_ZYNQMP + depends on !EFI_APP hex "Text Base" help TODO: Move CONFIG_SYS_TEXT_BASE for all the architecture

When running as an EFI application we must skip relocation. Add support for this in the x86 relocation code.

Signed-off-by: Simon Glass sjg@chromium.org ---

Changes in v2: - Return early in copy_uboot_to_ram() and clear_bbs() when relocation disabled

arch/x86/lib/relocate.c | 6 ++++++ 1 file changed, 6 insertions(+)

diff --git a/arch/x86/lib/relocate.c b/arch/x86/lib/relocate.c index 1a62142..9e748d2 100644 --- a/arch/x86/lib/relocate.c +++ b/arch/x86/lib/relocate.c @@ -28,6 +28,8 @@ int copy_uboot_to_ram(void) { size_t len = (size_t)&__data_end - (size_t)&__text_start;

+ if (gd->flags & GD_FLG_SKIP_RELOC) + return 0; memcpy((void *)gd->relocaddr, (void *)&__text_start, len);

return 0; @@ -38,6 +40,8 @@ int clear_bss(void) ulong dst_addr = (ulong)&__bss_start + gd->reloc_off; size_t len = (size_t)&__bss_end - (size_t)&__bss_start;

+ if (gd->flags & GD_FLG_SKIP_RELOC) + return 0; memset((void *)dst_addr, 0x00, len);

return 0; @@ -58,6 +62,8 @@ int do_elf_reloc_fixups(void) /* The size of the region of u-boot that runs out of RAM. */ uintptr_t size = (uintptr_t)&__bss_end - (uintptr_t)&__text_start;

+ if (gd->flags & GD_FLG_SKIP_RELOC) + return 0; if (re_src == re_end) panic("No relocation data");

Bring in this file from Linux 4.1. It supports relocation features specific to x86.

Signed-off-by: Simon Glass sjg@chromium.org Reviewed-by: Bin Meng bmeng.cn@gmail.com ---

Changes in v2: - Drop unneeded include of asm/ptrace.h - Fix comment style

arch/x86/include/asm/elf.h | 46 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 46 insertions(+) create mode 100644 arch/x86/include/asm/elf.h

diff --git a/arch/x86/include/asm/elf.h b/arch/x86/include/asm/elf.h new file mode 100644 index 0000000..3bdcdfe --- /dev/null +++ b/arch/x86/include/asm/elf.h @@ -0,0 +1,46 @@ +/* + * Brought in from Linux 4.1, removed things not useful to U-Boot. + * The definitions perhaps came from the GNU Library which is GPL. + * + * SPDX-License-Identifier: GPL-2.0+ + */ + +#ifndef _ASM_X86_ELF_H +#define _ASM_X86_ELF_H + +/* ELF register definitions */ +#define R_386_NONE 0 +#define R_386_32 1 +#define R_386_PC32 2 +#define R_386_GOT32 3 +#define R_386_PLT32 4 +#define R_386_COPY 5 +#define R_386_GLOB_DAT 6 +#define R_386_JMP_SLOT 7 +#define R_386_RELATIVE 8 +#define R_386_GOTOFF 9 +#define R_386_GOTPC 10 +#define R_386_NUM 11 + +/* x86-64 relocation types */ +#define R_X86_64_NONE 0 /* No reloc */ +#define R_X86_64_64 1 /* Direct 64 bit */ +#define R_X86_64_PC32 2 /* PC relative 32 bit signed */ +#define R_X86_64_GOT32 3 /* 32 bit GOT entry */ +#define R_X86_64_PLT32 4 /* 32 bit PLT address */ +#define R_X86_64_COPY 5 /* Copy symbol at runtime */ +#define R_X86_64_GLOB_DAT 6 /* Create GOT entry */ +#define R_X86_64_JUMP_SLOT 7 /* Create PLT entry */ +#define R_X86_64_RELATIVE 8 /* Adjust by program base */ +/* 32 bit signed pc relative offset to GOT */ +#define R_X86_64_GOTPCREL 9 +#define R_X86_64_32 10 /* Direct 32 bit zero extended */ +#define R_X86_64_32S 11 /* Direct 32 bit sign extended */ +#define R_X86_64_16 12 /* Direct 16 bit zero extended */ +#define R_X86_64_PC16 13 /* 16 bit sign extended pc relative */ +#define R_X86_64_8 14 /* Direct 8 bit sign extended */ +#define R_X86_64_PC8 15 /* 8 bit sign extended pc relative */ + +#define R_X86_64_NUM 16 + +#endif

From: Ben Stoltz stoltz@google.com

Add configuration and Kconfig changes for this board.

Signed-off-by: Ben Stoltz stoltz@google.com Signed-off-by: Simon Glass sjg@chromium.org ---

Changes in v2: - Remove CONFIG_SYS_EARLY_PCI_INIT and CONFIG_PCI_PNP - Remove superfluous Kconfig options - Rename CONFIG_ARCH_EFI to CONFIG_EFI_APP - Rename CONFIG_DEBUG_UART_EFI to CONFIG_DEBUG_EFI_CONSOLE

configs/efi-x86_defconfig | 16 ++++++++++++++++ include/configs/efi-x86.h | 34 ++++++++++++++++++++++++++++++++++ 2 files changed, 50 insertions(+) create mode 100644 configs/efi-x86_defconfig create mode 100644 include/configs/efi-x86.h

diff --git a/configs/efi-x86_defconfig b/configs/efi-x86_defconfig new file mode 100644 index 0000000..1aa0655 --- /dev/null +++ b/configs/efi-x86_defconfig @@ -0,0 +1,16 @@ +CONFIG_X86=y +CONFIG_VENDOR_EFI=y +CONFIG_TARGET_EFI=y +CONFIG_TSC_CALIBRATION_BYPASS=y +CONFIG_OF_CONTROL=y +CONFIG_OF_EMBED=y +CONFIG_DM_PCI=y +CONFIG_DEFAULT_DEVICE_TREE="efi" +CONFIG_EFI=y +CONFIG_EFI_APP=y +CONFIG_DEBUG_UART=y +CONFIG_DEBUG_EFI_CONSOLE=y +CONFIG_DEBUG_UART_BASE=0 +CONFIG_DEBUG_UART_CLOCK=0 +# CONFIG_CMD_NET is not set +# CONFIG_CMD_BOOTM is not set diff --git a/include/configs/efi-x86.h b/include/configs/efi-x86.h new file mode 100644 index 0000000..5779cfd --- /dev/null +++ b/include/configs/efi-x86.h @@ -0,0 +1,34 @@ +/* + * Copyright (c) 2015 Google, Inc + * + * SPDX-License-Identifier: GPL-2.0+ + */ + +#ifndef __CONFIG_H +#define __CONFIG_H + +#include <configs/x86-common.h> + +#undef CONFIG_CMD_SF_TEST + +#undef CONFIG_TPM +#undef CONFIG_TPM_TIS_LPC +#undef CONFIG_TPM_TIS_BASE_ADDRESS + +#undef CONFIG_CMD_IMLS + +#undef CONFIG_SYS_NS16550 +#undef CONFIG_X86_SERIAL +#undef CONFIG_ENV_IS_IN_SPI_FLASH +#define CONFIG_ENV_IS_NOWHERE +#undef CONFIG_VIDEO +#undef CONFIG_CFB_CONSOLE +#undef CONFIG_SCSI_AHCI +#undef CONFIG_CMD_SCSI +#undef CONFIG_INTEL_ICH6_GPIO + +#define CONFIG_STD_DEVICES_SETTINGS "stdin=usbkbd,vga,serial\0" \ + "stdout=vga,serial\0" \ + "stderr=vga,serial\0" + +#endif

Add a linker script and relocation code for building 64-bit EFI applications. This can be used for the EFI stub.

Signed-off-by: Simon Glass sjg@chromium.org Improvements to how the payload is built: Signed-off-by: Bin Meng bmeng.cn@gmail.com ---

Changes in v2: - Add a comment as to why .hash has to be first in the linker script - Change 'link script' to 'linker script' - Drop . = 0x0; - Fix reference to elf_ia32_efi instead of elf_x86_64_efi - Merge in Bin's implementation of adding a U-Boot payload with objcopy - Remove KEEP in the EFI linker script since garbage collection is not enabled - Rename ImageBase to image_base - Update based on the elf.h changes

arch/x86/cpu/efi/elf_x86_64_efi.lds | 83 +++++++++++++++++++++++++++++++++++++ arch/x86/lib/efi/reloc_x86_64.c | 66 +++++++++++++++++++++++++++++ 2 files changed, 149 insertions(+) create mode 100644 arch/x86/cpu/efi/elf_x86_64_efi.lds create mode 100644 arch/x86/lib/efi/reloc_x86_64.c

diff --git a/arch/x86/cpu/efi/elf_x86_64_efi.lds b/arch/x86/cpu/efi/elf_x86_64_efi.lds new file mode 100644 index 0000000..667fbe2 --- /dev/null +++ b/arch/x86/cpu/efi/elf_x86_64_efi.lds @@ -0,0 +1,83 @@ +/* + * U-Boot EFI linker script + * + * SPDX-License-Identifier: bsd-2-clause + * + * Modified from usr/lib32/elf_x86_64_efi.lds in gnu-efi + */ + +#include <config.h> + +OUTPUT_FORMAT("elf64-x86-64", "elf64-x86-64", "elf64-x86-64") +OUTPUT_ARCH(i386:x86-64) +ENTRY(_start) +SECTIONS +{ + image_base = .; + .hash : { *(.hash) } /* this MUST come first, EFI expects it */ + . = ALIGN(4096); + .eh_frame : { + *(.eh_frame) + } + + . = ALIGN(4096); + + .text : { + *(.text) + *(.text.*) + *(.gnu.linkonce.t.*) + } + + . = ALIGN(4096); + + .reloc : { + *(.reloc) + } + + . = ALIGN(4096); + + .data : { + *(.rodata*) + *(.got.plt) + *(.got) + *(.data*) + *(.sdata) + /* the EFI loader doesn't seem to like a .bss section, so we stick + * it all into .data: */ + *(.sbss) + *(.scommon) + *(.dynbss) + *(.bss) + *(COMMON) + *(.rel.local) + + /* U-Boot lists and device tree */ + . = ALIGN(8); + *(SORT(.u_boot_list*)); + . = ALIGN(8); + *(.dtb*); + } + + . = ALIGN(4096); + .dynamic : { *(.dynamic) } + . = ALIGN(4096); + + .rela : { + *(.rela.data*) + *(.rela.got) + *(.rela.stab) + } + + . = ALIGN(4096); + .dynsym : { *(.dynsym) } + . = ALIGN(4096); + .dynstr : { *(.dynstr) } + . = ALIGN(4096); + .ignored.reloc : { + *(.rela.reloc) + *(.eh_frame) + *(.note.GNU-stack) + } + + .comment 0 : { *(.comment) } +} diff --git a/arch/x86/lib/efi/reloc_x86_64.c b/arch/x86/lib/efi/reloc_x86_64.c new file mode 100644 index 0000000..5f71f2a --- /dev/null +++ b/arch/x86/lib/efi/reloc_x86_64.c @@ -0,0 +1,66 @@ +/* + * reloc_x86_64.c - position independent x86_64 ELF shared object relocator + * Copyright (C) 1999 Hewlett-Packard Co. + * Contributed by David Mosberger davidm@hpl.hp.com. + * Copyright (C) 2005 Intel Co. + * Contributed by Fenghua Yu fenghua.yu@intel.com. + * + * All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include <common.h> +#include <efi.h> +#include <elf.h> +#include <asm/elf.h> + +efi_status_t _relocate(long ldbase, Elf64_Dyn *dyn, efi_handle_t image, + struct efi_system_table *systab) +{ + long relsz = 0, relent = 0; + Elf64_Rel *rel = 0; + unsigned long *addr; + int i; + + for (i = 0; dyn[i].d_tag != DT_NULL; ++i) { + switch (dyn[i].d_tag) { + case DT_RELA: + rel = (Elf64_Rel *) + ((unsigned long)dyn[i].d_un.d_ptr + ldbase); + break; + case DT_RELASZ: + relsz = dyn[i].d_un.d_val; + break; + case DT_RELAENT: + relent = dyn[i].d_un.d_val; + break; + default: + break; + } + } + + if (!rel && relent == 0) + return EFI_SUCCESS; + + if (!rel || relent == 0) + return EFI_LOAD_ERROR; + + while (relsz > 0) { + /* apply the relocs */ + switch (ELF64_R_TYPE(rel->r_info)) { + case R_X86_64_NONE: + break; + case R_X86_64_RELATIVE: + addr = (unsigned long *)(ldbase + rel->r_offset); + *addr += ldbase; + break; + default: + break; + } + rel = (Elf64_Rel *)((char *)rel + relent); + relsz -= relent; + } + + return EFI_SUCCESS; +}

It is useful to be able to load U-Boot onto a board even it is it already running EFI. This can allow access to the U-Boot command interface, flexible booting options and easier development.

The easiest way to do this is to build U-Boot as a binary blob and have an EFI stub copy it into RAM. Add support for this feature, targeting 32-bit initially.

Also add a way to detect when U-Boot has been loaded via a stub. This goes in common.h since it needs to be widely available so that we avoid redoing initialisation that should be skipped.

Signed-off-by: Simon Glass sjg@chromium.org Improvements to how the payload is built: Signed-off-by: Bin Meng bmeng.cn@gmail.com ---

Changes in v2: - Add a comment as to why we must call exit_boot_services() twice - Drop \n\t at the end of a one-line asm statement - Merge in Bin's implementation of adding a U-Boot payload with objcopy - Remove comment about reset_cpu() returning to EFI in the stub - Rename CONFIG_ARCH_EFI to CONFIG_EFI_APP

Makefile | 21 ++++ arch/x86/config.mk | 3 + include/common.h | 7 ++ include/efi.h | 4 + lib/efi/Kconfig | 21 ++++ lib/efi/Makefile | 9 ++ lib/efi/efi_stub.c | 299 +++++++++++++++++++++++++++++++++++++++++++++++++++++ 7 files changed, 364 insertions(+) create mode 100644 lib/efi/efi_stub.c

diff --git a/Makefile b/Makefile index 6da9224..755eec8 100644 --- a/Makefile +++ b/Makefile @@ -751,6 +751,7 @@ ALL-$(CONFIG_SPL) += $(CONFIG_SPL_TARGET:"%"=%) endif ALL-$(CONFIG_REMAKE_ELF) += u-boot.elf ALL-$(CONFIG_EFI_APP) += u-boot-app.efi +ALL-$(CONFIG_EFI_STUB) += u-boot-payload.efi

ifneq ($(BUILD_ROM),) ALL-$(CONFIG_X86_RESET_VECTOR) += u-boot.rom @@ -786,6 +787,9 @@ cmd_objcopy = $(OBJCOPY) --gap-fill=0xff $(OBJCOPYFLAGS) \ quiet_cmd_zobjcopy = OBJCOPY $@ cmd_zobjcopy = $(OBJCOPY) $(OBJCOPYFLAGS) $(OBJCOPYFLAGS_$(@F)) $< $@

+quiet_cmd_efipayload = OBJCOPY $@ +cmd_efipayload = $(OBJCOPY) -I binary -O $(EFIPAYLOAD_BFDTARGET) -B $(EFIPAYLOAD_BFDARCH) $< $@ + quiet_cmd_mkimage = MKIMAGE $@ cmd_mkimage = $(objtree)/tools/mkimage $(MKIMAGEFLAGS_$(@F)) -d $< $@ \ $(if $(KBUILD_VERBOSE:1=), >/dev/null) @@ -1083,6 +1087,23 @@ OBJCOPYFLAGS_u-boot-app.efi := $(OBJCOPYFLAGS_EFI) u-boot-app.efi: u-boot FORCE $(call if_changed,zobjcopy)

+u-boot-dtb.bin.o: u-boot-dtb.bin FORCE + $(call if_changed,efipayload) + +u-boot-payload.lds: $(LDSCRIPT_EFI) FORCE + $(call if_changed_dep,cpp_lds) + +u-boot-payload: u-boot-dtb.bin.o u-boot-payload.lds \ + FORCE + $(LD) $(LDFLAGS_EFI) -o $@ \ + -T u-boot-payload.lds \ + lib/efi/efi.o lib/efi/efi_stub.o u-boot-dtb.bin.o \ + $(addprefix arch/$(ARCH)/lib/efi/,$(EFISTUB)) + +OBJCOPYFLAGS_u-boot-payload.efi := $(OBJCOPYFLAGS_EFI) +u-boot-payload.efi: u-boot-payload FORCE + $(call if_changed,zobjcopy) + u-boot-img.bin: spl/u-boot-spl.bin u-boot.img FORCE $(call if_changed,cat)

diff --git a/arch/x86/config.mk b/arch/x86/config.mk index a1c0eb2..48eb5f5 100644 --- a/arch/x86/config.mk +++ b/arch/x86/config.mk @@ -35,6 +35,9 @@ CFLAGS_NON_EFI := -mregparm=3 CFLAGS_EFI := -fpic -fshort-wchar

EFIARCH=ia32 +EFIPAYLOAD_BFDTARGET = elf32-i386 + +EFIPAYLOAD_BFDARCH = i386

LDSCRIPT_EFI := $(srctree)/$(CPUDIR)/efi/elf_$(EFIARCH)_efi.lds OBJCOPYFLAGS_EFI += --target=efi-app-$(EFIARCH) diff --git a/include/common.h b/include/common.h index 4566bd1..fcc9ae7 100644 --- a/include/common.h +++ b/include/common.h @@ -1021,6 +1021,13 @@ int cpu_release(int nr, int argc, char * const argv[]); offsetof(struct structure, member) == offset, \ "`struct " #structure "` offset for `" #member "` is not " #offset)

+/* Avoid using CONFIG_EFI_STUB directly as we may boot from other loaders */ +#ifdef CONFIG_EFI_STUB +#define ll_boot_init() false +#else +#define ll_boot_init() true +#endif + /* Pull in stuff for the build system */ #ifdef DO_DEPS_ONLY # include <environment.h> diff --git a/include/efi.h b/include/efi.h index 5d80373..34844e4 100644 --- a/include/efi.h +++ b/include/efi.h @@ -269,11 +269,15 @@ struct efi_priv { /* Base address of the EFI image */ extern char image_base[];

+/* Start and end of U-Boot image (for payload) */ +extern char _binary_u_boot_dtb_bin_start[], _binary_u_boot_dtb_bin_end[]; + /** * efi_get_sys_table() - Get access to the main EFI system table * * @return pointer to EFI system table */ + struct efi_system_table *efi_get_sys_table(void);

/** diff --git a/lib/efi/Kconfig b/lib/efi/Kconfig index b23ba5b..919e314 100644 --- a/lib/efi/Kconfig +++ b/lib/efi/Kconfig @@ -20,6 +20,11 @@ config EFI_APP 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 + config EFI_RAM_SIZE hex "Amount of EFI RAM for U-Boot" depends on EFI_APP @@ -30,4 +35,20 @@ config EFI_RAM_SIZE other smaller amounts) and it can never be increased after that. It is used as the RAM size in with U-Boot.

+choice + prompt "EFI 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 diff --git a/lib/efi/Makefile b/lib/efi/Makefile index 5ee344c..4bc67f0 100644 --- a/lib/efi/Makefile +++ b/lib/efi/Makefile @@ -5,3 +5,12 @@ #

obj-$(CONFIG_EFI_APP) += efi_app.o efi.o + +CFLAGS_REMOVE_efi_stub.o := -mregparm=3 \ + $(if $(CONFIG_EFI_STUB_64BIT),-march=i386 -m32) +CFLAGS_efi_stub.o := -fpic -fshort-wchar +CFLAGS_REMOVE_efi.o := -mregparm=3 \ + $(if $(CONFIG_EFI_STUB_64BIT),-march=i386 -m32) +CFLAGS_efi.o := -fpic -fshort-wchar + +extra-$(CONFIG_EFI_STUB) += efi_stub.o efi.o diff --git a/lib/efi/efi_stub.c b/lib/efi/efi_stub.c new file mode 100644 index 0000000..7259720 --- /dev/null +++ b/lib/efi/efi_stub.c @@ -0,0 +1,299 @@ +/* + * Copyright (c) 2015 Google, Inc + * + * SPDX-License-Identifier: GPL-2.0+ + * + * 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 a + * 32-bit EFI application. + */ + +#include <common.h> +#include <debug_uart.h> +#include <efi.h> +#include <efi_api.h> +#include <errno.h> +#include <ns16550.h> +#include <asm/cpu.h> +#include <asm/io.h> +#include <linux/err.h> +#include <linux/types.h> + +DECLARE_GLOBAL_DATA_PTR; + +#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 struct efi_priv *global_priv; +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) +{ + if (use_uart) { + NS16550_t com_port = (NS16550_t)0x3f8; + + while ((inb((ulong)&com_port->lsr) & UART_LSR_THRE) == 0) + ; + outb(ch, (ulong)&com_port->thr); + } else { + efi_putc(global_priv, ch); + } + if (ch == '\n') + putc('\r'); +} + +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) +{ + typedef void (*func_t)(int bist, int unused, ulong info); + +#ifdef CONFIG_EFI_STUB_32BIT + ((func_t)addr)(bist, 0, info); +#else + /* TODO: Implement this */ +#endif +} + +static void get_gdt(struct desctab_info *info) +{ + asm volatile ("sgdt %0" : : "m"(*info) : "memory"); +} + +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; + + /* TODO(sjg): Implement this for 64-bit mode */ + return cs32; +} + +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; +} + +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 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_mem_desc *desc; + struct efi_entry_memmap map; + ulong key, desc_size, size; + efi_status_t ret; + u32 version; + int cs32; + + ret = efi_init(priv, "Payload", image, sys_table); + if (ret) { + printhex2(ret); puts(" efi_init() failed\n"); + return ret; + } + global_priv = priv; + + cs32 = get_codeseg32(); + if (cs32 < 0) + return EFI_UNSUPPORTED; + + /* 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) { + printhex2(BITS_PER_LONG); + printhex2(ret); + puts(" No memory map\n"); + return ret; + } + size += 1024; /* Since doing a malloc() may change the memory map! */ + desc = efi_malloc(priv, size, &ret); + if (!desc) { + printhex2(ret); + puts(" No memory for memory descriptor: "); + return ret; + } + ret = setup_info_table(priv, size + 128); + if (ret) + return ret; + + ret = boot->get_memory_map(&size, desc, &key, &desc_size, &version); + if (ret) { + printhex2(ret); + puts(" Can't get memory map\n"); + return ret; + } + + ret = boot->exit_boot_services(image, key); + if (ret) { + /* + * Unfortunately it happens that we cannot exit boot services + * the first time. But the second time it work. I don't know + * why but this seems to be a repeatable problem. To get + * around it, just try again. + */ + printhex2(ret); + puts(" Can't exit boot services\n"); + size = sizeof(desc); + ret = boot->get_memory_map(&size, desc, &key, &desc_size, + &version); + if (ret) { + printhex2(ret); + puts(" Can't get memory map\n"); + return ret; + } + ret = boot->exit_boot_services(image, key); + if (ret) { + printhex2(ret); + puts(" Can't exit boot services 2\n"); + return ret; + } + } + + map.version = version; + map.desc_size = desc_size; + add_entry_addr(priv, EFIET_MEMORY_MAP, &map, sizeof(map), desc, size); + add_entry_addr(priv, EFIET_END, NULL, 0, 0, 0); + + /* The EFI UART won't work now, switch to a debug one */ + use_uart = true; + + memcpy((void *)CONFIG_SYS_TEXT_BASE, _binary_u_boot_dtb_bin_start, + (ulong)_binary_u_boot_dtb_bin_end - + (ulong)_binary_u_boot_dtb_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_SYS_TEXT_BASE, (ulong)priv->info); + + return EFI_LOAD_ERROR; +}

Add support for building a 32/64-bit EFI stub for x86. This involves building the startup and relocation code for either i386 or x86_64.

Signed-off-by: Simon Glass sjg@chromium.org ---

Changes in v2: - Add a comment as to why the AFLAGS_REMOVE_.. lines are needed - Move the crt and reloc files into arch/x86/lib/efi/

arch/x86/lib/Makefile | 2 +- arch/x86/lib/efi/Makefile | 24 ++++++++++++++++++++++++ 2 files changed, 25 insertions(+), 1 deletion(-) create mode 100644 arch/x86/lib/efi/Makefile

diff --git a/arch/x86/lib/Makefile b/arch/x86/lib/Makefile index 43489fd..09c236b 100644 --- a/arch/x86/lib/Makefile +++ b/arch/x86/lib/Makefile @@ -34,7 +34,7 @@ obj-$(CONFIG_SYS_X86_TSC_TIMER) += tsc_timer.o obj-$(CONFIG_CMD_ZBOOT) += zimage.o obj-$(CONFIG_HAVE_FSP) += fsp/

-extra-$(CONFIG_USE_PRIVATE_LIBGCC) := lib.a +extra-$(CONFIG_USE_PRIVATE_LIBGCC) += lib.a

NORMAL_LIBGCC = $(shell $(CC) $(PLATFORM_CPPFLAGS) -print-libgcc-file-name) OBJCOPYFLAGS := --prefix-symbols=__normal_ diff --git a/arch/x86/lib/efi/Makefile b/arch/x86/lib/efi/Makefile new file mode 100644 index 0000000..41295d9 --- /dev/null +++ b/arch/x86/lib/efi/Makefile @@ -0,0 +1,24 @@ +# +# (C) Copyright 2002-2006 +# Wolfgang Denk, DENX Software Engineering, wd@denx.de. +# +# SPDX-License-Identifier: GPL-2.0+ +# + +obj-$(CONFIG_EFI_APP) += crt0-efi-ia32.o reloc_ia32.o + +ifneq ($(CONFIG_EFI_STUB),) + +# When building for 64-bit we must remove the i386-specific flags +CFLAGS_REMOVE_reloc_ia32.o += -mregparm=3 +CFLAGS_reloc_ia32.o += -fpic -fshort-wchar + +CFLAGS_REMOVE_reloc_x86_64.o += -mregparm=3 -march=i386 -m32 +CFLAGS_reloc_x86_64.o += -fpic -fshort-wchar + +AFLAGS_REMOVE_crt0-efi-x86_64.o += -mregparm=3 -march=i386 -m32 +AFLAGS_crt0-efi-x86_64.o += -fpic -fshort-wchar + +extra-$(CONFIG_EFI_STUB_32BIT) += crt0-efi-ia32.o reloc_ia32.o +extra-$(CONFIG_EFI_STUB_64BIT) += crt0-efi-x86_64.o reloc_x86_64.o +endif