The EFI API header is great, but missing a good chunk of function prototype, GUID defines and enum declarations.

This patch extends it to cover more of the EFI API. It's still not 100% complete, but sufficient enough for our EFI payload interface.

Signed-off-by: Alexander Graf agraf@suse.de Reviewed-by: Simon Glass sjg@chromium.org Tested-by: Simon Glass sjg@chromium.org

---

v2 -> v3:

- Add EFIAPI to notify_function - Add access denied code

v3 -> v4:

- Add EFI_PAGE_MASK define --- include/efi.h | 2 + include/efi_api.h | 198 ++++++++++++++++++++++++++++++++++++++++++++---------- 2 files changed, 163 insertions(+), 37 deletions(-)

diff --git a/include/efi.h b/include/efi.h index fcafda0..1dbc3b7 100644 --- a/include/efi.h +++ b/include/efi.h @@ -38,6 +38,7 @@ struct efi_device_path; #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_ACCESS_DENIED (15 | (1UL << (BITS_PER_LONG - 1))) #define EFI_SECURITY_VIOLATION (26 | (1UL << (BITS_PER_LONG - 1)))

typedef unsigned long efi_status_t; @@ -139,6 +140,7 @@ enum {

#define EFI_PAGE_SHIFT 12 #define EFI_PAGE_SIZE (1UL << EFI_PAGE_SHIFT) +#define EFI_PAGE_MASK (EFI_PAGE_SIZE - 1)

struct efi_mem_desc { u32 type; diff --git a/include/efi_api.h b/include/efi_api.h index 4fd17d6..03f6687 100644 --- a/include/efi_api.h +++ b/include/efi_api.h @@ -17,11 +17,18 @@

#include <efi.h>

+/* Types and defines for EFI CreateEvent */ +enum efi_event_type { + EFI_TIMER_STOP = 0, + EFI_TIMER_PERIODIC = 1, + EFI_TIMER_RELATIVE = 2 +}; + /* EFI Boot Services table */ struct efi_boot_services { struct efi_table_hdr hdr; - void *raise_tpl; - void *restore_tpl; + efi_status_t (EFIAPI *raise_tpl)(unsigned long new_tpl); + void (EFIAPI *restore_tpl)(unsigned long old_tpl);

efi_status_t (EFIAPI *allocate_pages)(int, int, unsigned long, efi_physical_addr_t *); @@ -32,21 +39,33 @@ struct efi_boot_services { 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 *create_event)(enum efi_event_type type, + unsigned long notify_tpl, + void (EFIAPI *notify_function) (void *event, + void *context), + void *notify_context, void **event); + efi_status_t (EFIAPI *set_timer)(void *event, int type, + uint64_t trigger_time); + efi_status_t (EFIAPI *wait_for_event)(unsigned long number_of_events, + void *event, unsigned long *index); + efi_status_t (EFIAPI *signal_event)(void *event); + efi_status_t (EFIAPI *close_event)(void *event); + efi_status_t (EFIAPI *check_event)(void *event); + + efi_status_t (EFIAPI *install_protocol_interface)( + void **handle, efi_guid_t *protocol, + int protocol_interface_type, void *protocol_interface); + efi_status_t (EFIAPI *reinstall_protocol_interface)( + void *handle, efi_guid_t *protocol, + void *old_interface, void *new_interface); + efi_status_t (EFIAPI *uninstall_protocol_interface)(void *handle, + efi_guid_t *protocol, void *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 *register_protocol_notify)( + efi_guid_t *protocol, void *event, + void **registration); efi_status_t (EFIAPI *locate_handle)( enum efi_locate_search_type search_type, efi_guid_t *protocol, void *search_key, @@ -54,7 +73,8 @@ struct efi_boot_services { 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 *install_configuration_table)( + efi_guid_t *guid, void *table);

efi_status_t (EFIAPI *load_image)(bool boot_policiy, efi_handle_t parent_image, @@ -66,17 +86,20 @@ struct efi_boot_services { 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 *unload_image)(void *image_handle); 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 *set_watchdog_timer)(unsigned long timeout, + uint64_t watchdog_code, unsigned long data_size, + uint16_t *watchdog_data); 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; + efi_status_t (EFIAPI *disconnect_controller)(void *controller_handle, + void *driver_image_handle, void *child_handle); #define EFI_OPEN_PROTOCOL_BY_HANDLE_PROTOCOL 0x00000001 #define EFI_OPEN_PROTOCOL_GET_PROTOCOL 0x00000002 #define EFI_OPEN_PROTOCOL_TEST_PROTOCOL 0x00000004 @@ -87,7 +110,9 @@ struct efi_boot_services { 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 *close_protocol)(void *handle, + efi_guid_t *protocol, void *agent_handle, + void *controller_handle); efi_status_t(EFIAPI *open_protocol_information)(efi_handle_t handle, efi_guid_t *protocol, struct efi_open_protocol_info_entry **entry_buffer, @@ -99,12 +124,18 @@ struct efi_boot_services { 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; + efi_status_t (EFIAPI *locate_protocol)(efi_guid_t *protocol, + void *registration, void **protocol_interface); + efi_status_t (EFIAPI *install_multiple_protocol_interfaces)( + void **handle, ...); + efi_status_t (EFIAPI *uninstall_multiple_protocol_interfaces)( + void *handle, ...); + efi_status_t (EFIAPI *calculate_crc32)(void *data, + unsigned long data_size, uint32_t *crc32); + void (EFIAPI *copy_mem)(void *destination, void *source, + unsigned long length); + void (EFIAPI *set_mem)(void *buffer, unsigned long size, + uint8_t value); void *create_event_ex; };

@@ -121,12 +152,19 @@ enum efi_reset_type {

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_time)(struct efi_time *time, + struct efi_time_cap *capabilities); + efi_status_t (EFIAPI *set_time)(struct efi_time *time); + efi_status_t (EFIAPI *get_wakeup_time)(char *enabled, char *pending, + struct efi_time *time); + efi_status_t (EFIAPI *set_wakeup_time)(char enabled, + struct efi_time *time); + efi_status_t (EFIAPI *set_virtual_address_map)( + unsigned long memory_map_size, + unsigned long descriptor_size, + uint32_t descriptor_version, + struct efi_mem_desc *virtmap); + efi_status_t (*convert_pointer)(unsigned long dbg, void **address); efi_status_t (EFIAPI *get_variable)(s16 *variable_name, efi_guid_t *vendor, u32 *attributes, unsigned long *data_size, void *data); @@ -136,7 +174,8 @@ struct efi_runtime_services { 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; + efi_status_t (EFIAPI *get_next_high_mono_count)( + uint32_t *high_count); void (EFIAPI *reset_system)(enum efi_reset_type reset_type, efi_status_t reset_status, unsigned long data_size, void *reset_data); @@ -154,6 +193,18 @@ struct efi_runtime_services { EFI_GUID(0x5b1b31a1, 0x9562, 0x11d2, 0x8e, 0x3f, \ 0x00, 0xa0, 0xc9, 0x69, 0x72, 0x3b)

+#define EFI_FDT_GUID \ + EFI_GUID(0xb1b621d5, 0xf19c, 0x41a5, \ + 0x83, 0x0b, 0xd9, 0x15, 0x2c, 0x69, 0xaa, 0xe0) + +struct efi_configuration_table +{ + efi_guid_t guid; + void *table; +}; + +#define EFI_SYSTEM_TABLE_SIGNATURE ((u64)0x5453595320494249ULL) + struct efi_system_table { struct efi_table_hdr hdr; unsigned long fw_vendor; /* physical addr of wchar_t vendor string */ @@ -163,13 +214,17 @@ struct efi_system_table { unsigned long con_out_handle; struct efi_simple_text_output_protocol *con_out; unsigned long stderr_handle; - unsigned long std_err; + struct efi_simple_text_output_protocol *std_err; struct efi_runtime_services *runtime; struct efi_boot_services *boottime; unsigned long nr_tables; - unsigned long tables; + struct efi_configuration_table *tables; };

+#define LOADED_IMAGE_GUID \ + EFI_GUID(0x5b1b31a1, 0x9562, 0x11d2, \ + 0x8e, 0x3f, 0x00, 0xa0, 0xc9, 0x69, 0x72, 0x3b) + struct efi_loaded_image { u32 revision; void *parent_handle; @@ -186,12 +241,60 @@ struct efi_loaded_image { unsigned long unload; };

+#define DEVICE_PATH_GUID \ + EFI_GUID(0x09576e91, 0x6d3f, 0x11d2, \ + 0x8e, 0x39, 0x00, 0xa0, 0xc9, 0x69, 0x72, 0x3b ) + +#define DEVICE_PATH_TYPE_END 0x7f +# define DEVICE_PATH_SUB_TYPE_END 0xff + struct efi_device_path { u8 type; u8 sub_type; u16 length; };

+#define DEVICE_PATH_TYPE_MEDIA_DEVICE 0x04 +# define DEVICE_PATH_SUB_TYPE_FILE_PATH 0x04 + +struct efi_device_path_file_path { + struct efi_device_path dp; + u16 str[16]; +}; + +#define BLOCK_IO_GUID \ + EFI_GUID(0x964e5b21, 0x6459, 0x11d2, \ + 0x8e, 0x39, 0x00, 0xa0, 0xc9, 0x69, 0x72, 0x3b) + +struct efi_block_io_media +{ + u32 media_id; + char removable_media; + char media_present; + char logical_partition; + char read_only; + char write_caching; + u8 pad[3]; + u32 block_size; + u32 io_align; + u8 pad2[4]; + u64 last_block; +}; + +struct efi_block_io { + u64 revision; + struct efi_block_io_media *media; + efi_status_t (EFIAPI *reset)(struct efi_block_io *this, + char extended_verification); + efi_status_t (EFIAPI *read_blocks)(struct efi_block_io *this, + u32 media_id, u64 lba, unsigned long buffer_size, + void *buffer); + efi_status_t (EFIAPI *write_blocks)(struct efi_block_io *this, + u32 media_id, u64 lba, unsigned long buffer_size, + void *buffer); + efi_status_t (EFIAPI *flush_blocks)(struct efi_block_io *this); +}; + struct simple_text_output_mode { s32 max_mode; s32 mode; @@ -206,8 +309,9 @@ struct efi_simple_text_output_protocol { efi_status_t (EFIAPI *output_string)( struct efi_simple_text_output_protocol *this, const unsigned short *str); - void *test_string; - + efi_status_t (EFIAPI *test_string)( + struct efi_simple_text_output_protocol *this, + const unsigned short *str); efi_status_t(EFIAPI *query_mode)( struct efi_simple_text_output_protocol *this, unsigned long mode_number, unsigned long *columns, @@ -223,7 +327,9 @@ struct efi_simple_text_output_protocol { 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); + efi_status_t(EFIAPI *enable_cursor)( + struct efi_simple_text_output_protocol *this, + bool enable); struct simple_text_output_mode *mode; };

@@ -241,4 +347,22 @@ struct efi_simple_input_interface { void *wait_for_key; };

+#define CONSOLE_CONTROL_GUID \ + EFI_GUID(0xf42f7782, 0x12e, 0x4c12, \ + 0x99, 0x56, 0x49, 0xf9, 0x43, 0x4, 0xf7, 0x21) +#define EFI_CONSOLE_MODE_TEXT 0 +#define EFI_CONSOLE_MODE_GFX 1 + +struct efi_console_control_protocol +{ + efi_status_t (EFIAPI *get_mode)( + struct efi_console_control_protocol *this, int *mode, + char *uga_exists, char *std_in_locked); + efi_status_t (EFIAPI *set_mode)( + struct efi_console_control_protocol *this, int mode); + efi_status_t (EFIAPI *lock_std_in)( + struct efi_console_control_protocol *this, + uint16_t *password); +}; + #endif

When an EFI application runs, it has access to a few descriptor and callback tables to instruct the EFI compliant firmware to do things for it. The bulk of those interfaces are "boot time services". They handle all object management, and memory allocation.

This patch adds support for the boot time services and also exposes a system table, which is the point of entry descriptor table for EFI payloads.

Signed-off-by: Alexander Graf agraf@suse.de Reviewed-by: Simon Glass sjg@chromium.org Tested-by: Simon Glass sjg@chromium.org

---

v1 -> v2:

- Fix typo s/does now/does not/ - Add #ifdefs around header to allow inclusion when efi_loader is disabled - Add stub efi_restore_gd() function when efi_loader is disabled - Disable debug - Mark runtime region as such - Fix up memory map - Allow efi_restore_gd to be called before first efi entry - Add 32bit arm cache workaround - Move memory map to separate patch - Change BTS version to 2.5 - Fix return values for a few callbacks to more EFI compliant ones - Change vendor to "Das U-Boot" - Add warning when truncating timer trigger - Move to GPLv2+

v2 -> v3:

- Use external efi_memory helpers - Add EFIAPI to function prototypes - Initialize event timer to -1ULL to prevent early firing - Document header - Move obj list to lib - Remove implicit guid table - Add guid compare function - Fix return values - Implement efi_wait_for_event - Implement efi_install_configuration_table

v3 -> v4:

- s/polimorphic/polymorphic --- include/efi_loader.h | 84 +++++ lib/efi_loader/efi_boottime.c | 781 ++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 865 insertions(+) create mode 100644 lib/efi_loader/efi_boottime.c

diff --git a/include/efi_loader.h b/include/efi_loader.h index 5618185..d63fa3a 100644 --- a/include/efi_loader.h +++ b/include/efi_loader.h @@ -6,15 +6,99 @@ * SPDX-License-Identifier: GPL-2.0+ */

+#include <common.h> #include <part_efi.h> #include <efi_api.h> + +#ifdef CONFIG_EFI_LOADER + #include <linux/list.h>

+/* #define DEBUG_EFI */ + +#ifdef DEBUG_EFI +#define EFI_ENTRY(format, ...) do { \ + efi_restore_gd(); \ + printf("EFI: Entry %s(" format ")\n", __func__, ##__VA_ARGS__); \ + } while(0) +#else +#define EFI_ENTRY(format, ...) do { \ + efi_restore_gd(); \ + } while(0) +#endif + +#define EFI_EXIT(ret) efi_exit_func(ret); + +extern struct efi_system_table systab; + extern const efi_guid_t efi_guid_device_path; extern const efi_guid_t efi_guid_loaded_image;

+/* + * While UEFI objects can have callbacks, you can also call functions on + * protocols (classes) themselves. This struct maps a protocol GUID to its + * interface (usually a struct with callback functions). + */ +struct efi_class_map { + const efi_guid_t *guid; + const void *interface; +}; + +/* + * When the UEFI payload wants to open a protocol on an object to get its + * interface (usually a struct with callback functions), this struct maps the + * protocol GUID to the respective protocol handler open function for that + * object protocol combination. + */ +struct efi_handler { + const efi_guid_t *guid; + efi_status_t (EFIAPI *open)(void *handle, + efi_guid_t *protocol, void **protocol_interface, + void *agent_handle, void *controller_handle, + uint32_t attributes); +}; + +/* + * UEFI has a poor man's OO model where one "object" can be polymorphic and have + * multiple different protocols (classes) attached to it. + * + * This struct is the parent struct for all of our actual implementation objects + * that can include it to make themselves an EFI object + */ +struct efi_object { + /* Every UEFI object is part of a global object list */ + struct list_head link; + /* We support up to 4 "protocols" an object can be accessed through */ + struct efi_handler protocols[4]; + /* The object spawner can either use this for data or as identifier */ + void *handle; +}; + +/* This list contains all UEFI objects we know of */ +extern struct list_head efi_obj_list; + +/* + * Stub implementation for a protocol opener that just returns the handle as + * interface + */ efi_status_t efi_return_handle(void *handle, efi_guid_t *protocol, void **protocol_interface, void *agent_handle, void *controller_handle, uint32_t attributes); +/* Called from places to check whether a timer expired */ +void efi_timer_check(void); +/* PE loader implementation */ void *efi_load_pe(void *efi, struct efi_loaded_image *loaded_image_info); +/* Called once to store the pristine gd pointer */ +void efi_save_gd(void); +/* Called from EFI_ENTRY on callback entry to put gd into the gd register */ +void efi_restore_gd(void); +/* Called from EFI_EXIT on callback exit to restore the gd register */ +efi_status_t efi_exit_func(efi_status_t ret); + +#else /* defined(EFI_LOADER) */ + +/* No loader configured, stub out EFI_ENTRY */ +static inline void efi_restore_gd(void) { } + +#endif diff --git a/lib/efi_loader/efi_boottime.c b/lib/efi_loader/efi_boottime.c new file mode 100644 index 0000000..e60fae9 --- /dev/null +++ b/lib/efi_loader/efi_boottime.c @@ -0,0 +1,781 @@ +/* + * EFI application boot time services + * + * Copyright (c) 2016 Alexander Graf + * + * SPDX-License-Identifier: GPL-2.0+ + */ + +/* #define DEBUG_EFI */ + +#include <common.h> +#include <efi_loader.h> +#include <malloc.h> +#include <asm/global_data.h> +#include <libfdt_env.h> +#include <u-boot/crc.h> +#include <bootm.h> +#include <inttypes.h> +#include <watchdog.h> + +DECLARE_GLOBAL_DATA_PTR; + +/* This list contains all the EFI objects our payload has access to */ +LIST_HEAD(efi_obj_list); + +/* + * If we're running on nasty systems (32bit ARM booting into non-EFI Linux) + * we need to do trickery with caches. Since we don't want to break the EFI + * aware boot path, only apply hacks when loading exiting directly (breaking + * direct Linux EFI booting along the way - oh well). + */ +static bool efi_is_direct_boot = true; + +/* + * EFI can pass arbitrary additional "tables" containing vendor specific + * information to the payload. One such table is the FDT table which contains + * a pointer to a flattened device tree blob. + * + * In most cases we want to pass an FDT to the payload, so reserve one slot of + * config table space for it. The pointer gets populated by do_bootefi_exec(). + */ +static struct efi_configuration_table efi_conf_table[1]; + +/* + * The "gd" pointer lives in a register on ARM and AArch64 that we declare + * fixed when compiling U-Boot. However, the payload does not know about that + * restriction so we need to manually swap its and our view of that register on + * EFI callback entry/exit. + */ +static volatile void *efi_gd, *app_gd; + +/* Called from do_bootefi_exec() */ +void efi_save_gd(void) +{ + efi_gd = gd; +} + +/* Called on every callback entry */ +void efi_restore_gd(void) +{ + /* Only restore if we're already in EFI context */ + if (!efi_gd) + return; + + if (gd != efi_gd) + app_gd = gd; + gd = efi_gd; +} + +/* Called on every callback exit */ +efi_status_t efi_exit_func(efi_status_t ret) +{ + gd = app_gd; + return ret; +} + +static efi_status_t efi_unsupported(const char *funcname) +{ +#ifdef DEBUG_EFI + printf("EFI: App called into unimplemented function %s\n", funcname); +#endif + return EFI_EXIT(EFI_UNSUPPORTED); +} + +static int guidcmp(const efi_guid_t *g1, const efi_guid_t *g2) +{ + return memcmp(g1, g2, sizeof(efi_guid_t)); +} + +static unsigned long EFIAPI efi_raise_tpl(unsigned long new_tpl) +{ + EFI_ENTRY("0x%lx", new_tpl); + return EFI_EXIT(0); +} + +static void EFIAPI efi_restore_tpl(unsigned long old_tpl) +{ + EFI_ENTRY("0x%lx", old_tpl); + EFI_EXIT(efi_unsupported(__func__)); +} + +efi_status_t EFIAPI efi_allocate_pages_ext(int type, int memory_type, + unsigned long pages, + uint64_t *memory) +{ + efi_status_t r; + + EFI_ENTRY("%d, %d, 0x%lx, %p", type, memory_type, pages, memory); + r = efi_allocate_pages(type, memory_type, pages, memory); + return EFI_EXIT(r); +} + +efi_status_t EFIAPI efi_free_pages_ext(uint64_t memory, unsigned long pages) +{ + efi_status_t r; + + EFI_ENTRY("%"PRIx64", 0x%lx", memory, pages); + r = efi_free_pages(memory, pages); + return EFI_EXIT(r); +} + +efi_status_t EFIAPI efi_get_memory_map_ext(unsigned long *memory_map_size, + struct efi_mem_desc *memory_map, + unsigned long *map_key, + unsigned long *descriptor_size, + uint32_t *descriptor_version) +{ + efi_status_t r; + + EFI_ENTRY("%p, %p, %p, %p, %p", memory_map_size, memory_map, + map_key, descriptor_size, descriptor_version); + r = efi_get_memory_map(memory_map_size, memory_map, map_key, + descriptor_size, descriptor_version); + return EFI_EXIT(r); +} + +static efi_status_t EFIAPI efi_allocate_pool(int pool_type, unsigned long size, + void **buffer) +{ + return efi_allocate_pages(0, pool_type, (size + 0xfff) >> 12, (void*)buffer); +} + +static efi_status_t EFIAPI efi_free_pool(void *buffer) +{ + return efi_free_pages((ulong)buffer, 0); +} + +/* + * Our event capabilities are very limited. Only support a single + * event to exist, so we don't need to maintain lists. + */ +static struct { + enum efi_event_type type; + u32 trigger_type; + u32 trigger_time; + u64 trigger_next; + unsigned long notify_tpl; + void (*notify_function) (void *event, void *context); + void *notify_context; +} efi_event = { + /* Disable timers on bootup */ + .trigger_next = -1ULL, +}; + +static efi_status_t EFIAPI efi_create_event( + enum efi_event_type type, ulong notify_tpl, + void (*notify_function) (void *event, void *context), + void *notify_context, void **event) +{ + EFI_ENTRY("%d, 0x%lx, %p, %p", type, notify_tpl, notify_function, + notify_context); + if (efi_event.notify_function) { + /* We only support one event at a time */ + return EFI_EXIT(EFI_OUT_OF_RESOURCES); + } + + efi_event.type = type; + efi_event.notify_tpl = notify_tpl; + efi_event.notify_function = notify_function; + efi_event.notify_context = notify_context; + *event = &efi_event; + + return EFI_EXIT(EFI_SUCCESS); +} + +/* + * Our timers have to work without interrupts, so we check whenever keyboard + * input or disk accesses happen if enough time elapsed for it to fire. + */ +void efi_timer_check(void) +{ + u64 now = timer_get_us(); + + if (now >= efi_event.trigger_next) { + /* Triggering! */ + if (efi_event.trigger_type == EFI_TIMER_PERIODIC) + efi_event.trigger_next += efi_event.trigger_time / 10; + efi_event.notify_function(&efi_event, efi_event.notify_context); + } + + WATCHDOG_RESET(); +} + +static efi_status_t EFIAPI efi_set_timer(void *event, int type, + uint64_t trigger_time) +{ + /* We don't have 64bit division available everywhere, so limit timer + * distances to 32bit bits. */ + u32 trigger32 = trigger_time; + + EFI_ENTRY("%p, %d, %"PRIx64, event, type, trigger_time); + + if (trigger32 < trigger_time) { + printf("WARNING: Truncating timer from %"PRIx64" to %x\n", + trigger_time, trigger32); + } + + if (event != &efi_event) { + /* We only support one event at a time */ + return EFI_EXIT(EFI_INVALID_PARAMETER); + } + + switch (type) { + case EFI_TIMER_STOP: + efi_event.trigger_next = -1ULL; + break; + case EFI_TIMER_PERIODIC: + case EFI_TIMER_RELATIVE: + efi_event.trigger_next = timer_get_us() + (trigger32 / 10); + break; + default: + return EFI_EXIT(EFI_INVALID_PARAMETER); + } + efi_event.trigger_type = type; + efi_event.trigger_time = trigger_time; + + return EFI_EXIT(EFI_SUCCESS); +} + +static efi_status_t EFIAPI efi_wait_for_event(unsigned long num_events, + void *event, unsigned long *index) +{ + u64 now; + + EFI_ENTRY("%ld, %p, %p", num_events, event, index); + + now = timer_get_us(); + while (now < efi_event.trigger_next) { } + efi_timer_check(); + + return EFI_EXIT(EFI_SUCCESS); +} + +static efi_status_t EFIAPI efi_signal_event(void *event) +{ + EFI_ENTRY("%p", event); + return EFI_EXIT(EFI_SUCCESS); +} + +static efi_status_t EFIAPI efi_close_event(void *event) +{ + EFI_ENTRY("%p", event); + efi_event.trigger_next = -1ULL; + return EFI_EXIT(EFI_SUCCESS); +} + +static efi_status_t EFIAPI efi_check_event(void *event) +{ + EFI_ENTRY("%p", event); + return EFI_EXIT(EFI_NOT_READY); +} + +static efi_status_t EFIAPI efi_install_protocol_interface(void **handle, + efi_guid_t *protocol, int protocol_interface_type, + void *protocol_interface) +{ + EFI_ENTRY("%p, %p, %d, %p", handle, protocol, protocol_interface_type, + protocol_interface); + return EFI_EXIT(EFI_OUT_OF_RESOURCES); +} +static efi_status_t EFIAPI efi_reinstall_protocol_interface(void *handle, + efi_guid_t *protocol, void *old_interface, + void *new_interface) +{ + EFI_ENTRY("%p, %p, %p, %p", handle, protocol, old_interface, + new_interface); + return EFI_EXIT(EFI_ACCESS_DENIED); +} + +static efi_status_t EFIAPI efi_uninstall_protocol_interface(void *handle, + efi_guid_t *protocol, void *protocol_interface) +{ + EFI_ENTRY("%p, %p, %p", handle, protocol, protocol_interface); + return EFI_EXIT(EFI_NOT_FOUND); +} + +static efi_status_t EFIAPI efi_register_protocol_notify(efi_guid_t *protocol, + void *event, + void **registration) +{ + EFI_ENTRY("%p, %p, %p", protocol, event, registration); + return EFI_EXIT(EFI_OUT_OF_RESOURCES); +} + +static int efi_search(enum efi_locate_search_type search_type, + efi_guid_t *protocol, void *search_key, + struct efi_object *efiobj) +{ + int i; + + switch (search_type) { + case all_handles: + return 0; + case by_register_notify: + return -1; + case by_protocol: + for (i = 0; i < ARRAY_SIZE(efiobj->protocols); i++) { + const efi_guid_t *guid = efiobj->protocols[i].guid; + if (guid && !guidcmp(guid, protocol)) + return 0; + } + return -1; + } + + return -1; +} + +static efi_status_t EFIAPI efi_locate_handle( + enum efi_locate_search_type search_type, + efi_guid_t *protocol, void *search_key, + unsigned long *buffer_size, efi_handle_t *buffer) +{ + struct list_head *lhandle; + unsigned long size = 0; + + EFI_ENTRY("%d, %p, %p, %p, %p", search_type, protocol, search_key, + buffer_size, buffer); + + /* Count how much space we need */ + list_for_each(lhandle, &efi_obj_list) { + struct efi_object *efiobj; + efiobj = list_entry(lhandle, struct efi_object, link); + if (!efi_search(search_type, protocol, search_key, efiobj)) { + size += sizeof(void*); + } + } + + if (*buffer_size < size) { + *buffer_size = size; + return EFI_EXIT(EFI_BUFFER_TOO_SMALL); + } + + /* Then fill the array */ + list_for_each(lhandle, &efi_obj_list) { + struct efi_object *efiobj; + efiobj = list_entry(lhandle, struct efi_object, link); + if (!efi_search(search_type, protocol, search_key, efiobj)) { + *(buffer++) = efiobj->handle; + } + } + + *buffer_size = size; + return EFI_EXIT(EFI_SUCCESS); +} + +static efi_status_t EFIAPI efi_locate_device_path(efi_guid_t *protocol, + struct efi_device_path **device_path, + efi_handle_t *device) +{ + EFI_ENTRY("%p, %p, %p", protocol, device_path, device); + return EFI_EXIT(EFI_NOT_FOUND); +} + +static efi_status_t EFIAPI efi_install_configuration_table(efi_guid_t *guid, + void *table) +{ + int i; + + EFI_ENTRY("%p, %p", guid, table); + + /* Check for guid override */ + for (i = 0; i < systab.nr_tables; i++) { + if (!guidcmp(guid, &efi_conf_table[i].guid)) { + efi_conf_table[i].table = table; + return EFI_EXIT(EFI_SUCCESS); + } + } + + /* No override, check for overflow */ + if (i >= ARRAY_SIZE(efi_conf_table)) + return EFI_EXIT(EFI_OUT_OF_RESOURCES); + + /* Add a new entry */ + memcpy(&efi_conf_table[i].guid, guid, sizeof(*guid)); + efi_conf_table[i].table = table; + systab.nr_tables = i; + + return EFI_EXIT(EFI_SUCCESS); +} + +static efi_status_t EFIAPI efi_load_image(bool boot_policy, + efi_handle_t parent_image, + struct efi_device_path *file_path, + void *source_buffer, + unsigned long source_size, + efi_handle_t *image_handle) +{ + static struct efi_object loaded_image_info_obj = { + .protocols = { + { + .guid = &efi_guid_loaded_image, + .open = &efi_return_handle, + }, + }, + }; + struct efi_loaded_image *info; + struct efi_object *obj; + + EFI_ENTRY("%d, %p, %p, %p, %ld, %p", boot_policy, parent_image, + file_path, source_buffer, source_size, image_handle); + info = malloc(sizeof(*info)); + obj = malloc(sizeof(loaded_image_info_obj)); + memset(info, 0, sizeof(*info)); + memcpy(obj, &loaded_image_info_obj, sizeof(loaded_image_info_obj)); + obj->handle = info; + info->file_path = file_path; + info->reserved = efi_load_pe(source_buffer, info); + if (!info->reserved) { + free(info); + free(obj); + return EFI_EXIT(EFI_UNSUPPORTED); + } + + *image_handle = info; + list_add_tail(&obj->link, &efi_obj_list); + + return EFI_EXIT(EFI_SUCCESS); +} + +static efi_status_t EFIAPI efi_start_image(efi_handle_t image_handle, + unsigned long *exit_data_size, + s16 **exit_data) +{ + ulong (*entry)(void *image_handle, struct efi_system_table *st); + struct efi_loaded_image *info = image_handle; + + EFI_ENTRY("%p, %p, %p", image_handle, exit_data_size, exit_data); + entry = info->reserved; + + efi_is_direct_boot = false; + + /* call the image! */ + entry(image_handle, &systab); + + /* Should usually never get here */ + return EFI_EXIT(EFI_SUCCESS); +} + +static efi_status_t EFIAPI efi_exit(void *image_handle, long exit_status, + unsigned long exit_data_size, + uint16_t *exit_data) +{ + EFI_ENTRY("%p, %ld, %ld, %p", image_handle, exit_status, + exit_data_size, exit_data); + return EFI_EXIT(efi_unsupported(__func__)); +} + +static struct efi_object *efi_search_obj(void *handle) +{ + struct list_head *lhandle; + + list_for_each(lhandle, &efi_obj_list) { + struct efi_object *efiobj; + efiobj = list_entry(lhandle, struct efi_object, link); + if (efiobj->handle == handle) + return efiobj; + } + + return NULL; +} + +static efi_status_t EFIAPI efi_unload_image(void *image_handle) +{ + struct efi_object *efiobj; + + EFI_ENTRY("%p", image_handle); + efiobj = efi_search_obj(image_handle); + if (efiobj) + list_del(&efiobj->link); + + return EFI_EXIT(EFI_SUCCESS); +} + +static void efi_exit_caches(void) +{ +#if defined(CONFIG_ARM) && !defined(CONFIG_ARM64) + /* + * Grub on 32bit ARM needs to have caches disabled before jumping into + * a zImage, but does not know of all cache layers. Give it a hand. + */ + if (efi_is_direct_boot) + cleanup_before_linux(); +#endif +} + +static efi_status_t EFIAPI efi_exit_boot_services(void *image_handle, + unsigned long map_key) +{ + EFI_ENTRY("%p, %ld", image_handle, map_key); + + /* Fix up caches for EFI payloads if necessary */ + efi_exit_caches(); + + /* This stops all lingering devices */ + bootm_disable_interrupts(); + + /* Give the payload some time to boot */ + WATCHDOG_RESET(); + + return EFI_EXIT(EFI_SUCCESS); +} + +static efi_status_t EFIAPI efi_get_next_monotonic_count(uint64_t *count) +{ + static uint64_t mono = 0; + EFI_ENTRY("%p", count); + *count = mono++; + return EFI_EXIT(EFI_SUCCESS); +} + +static efi_status_t EFIAPI efi_stall(unsigned long microseconds) +{ + EFI_ENTRY("%ld", microseconds); + udelay(microseconds); + return EFI_EXIT(EFI_SUCCESS); +} + +static efi_status_t EFIAPI efi_set_watchdog_timer(unsigned long timeout, + uint64_t watchdog_code, + unsigned long data_size, + uint16_t *watchdog_data) +{ + EFI_ENTRY("%ld, 0x%"PRIx64", %ld, %p", timeout, watchdog_code, + data_size, watchdog_data); + return EFI_EXIT(efi_unsupported(__func__)); +} + +static efi_status_t EFIAPI efi_connect_controller( + efi_handle_t controller_handle, + efi_handle_t *driver_image_handle, + struct efi_device_path *remain_device_path, + bool recursive) +{ + EFI_ENTRY("%p, %p, %p, %d", controller_handle, driver_image_handle, + remain_device_path, recursive); + return EFI_EXIT(EFI_NOT_FOUND); +} + +static efi_status_t EFIAPI efi_disconnect_controller(void *controller_handle, + void *driver_image_handle, + void *child_handle) +{ + EFI_ENTRY("%p, %p, %p", controller_handle, driver_image_handle, + child_handle); + return EFI_EXIT(EFI_INVALID_PARAMETER); +} + +static efi_status_t EFIAPI efi_close_protocol(void *handle, + efi_guid_t *protocol, + void *agent_handle, + void *controller_handle) +{ + EFI_ENTRY("%p, %p, %p, %p", handle, protocol, agent_handle, + controller_handle); + return EFI_EXIT(EFI_NOT_FOUND); +} + +static efi_status_t EFIAPI efi_open_protocol_information(efi_handle_t handle, + efi_guid_t *protocol, + struct efi_open_protocol_info_entry **entry_buffer, + unsigned long *entry_count) +{ + EFI_ENTRY("%p, %p, %p, %p", handle, protocol, entry_buffer, + entry_count); + return EFI_EXIT(EFI_NOT_FOUND); +} + +static efi_status_t EFIAPI efi_protocols_per_handle(void *handle, + efi_guid_t ***protocol_buffer, + unsigned long *protocol_buffer_count) +{ + EFI_ENTRY("%p, %p, %p", handle, protocol_buffer, + protocol_buffer_count); + return EFI_EXIT(EFI_OUT_OF_RESOURCES); +} + +static efi_status_t EFIAPI efi_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) +{ + EFI_ENTRY("%d, %p, %p, %p, %p", search_type, protocol, search_key, + no_handles, buffer); + return EFI_EXIT(EFI_NOT_FOUND); +} + +static struct efi_class_map efi_class_maps[] = { + { + .guid = &efi_guid_console_control, + .interface = &efi_console_control + }, +}; + +static efi_status_t EFIAPI efi_locate_protocol(efi_guid_t *protocol, + void *registration, + void **protocol_interface) +{ + int i; + + EFI_ENTRY("%p, %p, %p", protocol, registration, protocol_interface); + for (i = 0; i < ARRAY_SIZE(efi_class_maps); i++) { + struct efi_class_map *curmap = &efi_class_maps[i]; + if (!guidcmp(protocol, curmap->guid)) { + *protocol_interface = (void*)curmap->interface; + return EFI_EXIT(EFI_SUCCESS); + } + } + + return EFI_EXIT(EFI_NOT_FOUND); +} + +static efi_status_t EFIAPI efi_install_multiple_protocol_interfaces( + void **handle, ...) +{ + EFI_ENTRY("%p", handle); + return EFI_EXIT(EFI_OUT_OF_RESOURCES); +} + +static efi_status_t EFIAPI efi_uninstall_multiple_protocol_interfaces( + void *handle, ...) +{ + EFI_ENTRY("%p", handle); + return EFI_EXIT(EFI_INVALID_PARAMETER); +} + +static efi_status_t EFIAPI efi_calculate_crc32(void *data, + unsigned long data_size, + uint32_t *crc32_p) +{ + EFI_ENTRY("%p, %ld", data, data_size); + *crc32_p = crc32(0, data, data_size); + return EFI_EXIT(EFI_SUCCESS); +} + +static void EFIAPI efi_copy_mem(void *destination, void *source, + unsigned long length) +{ + EFI_ENTRY("%p, %p, %ld", destination, source, length); + memcpy(destination, source, length); +} + +static void EFIAPI efi_set_mem(void *buffer, unsigned long size, uint8_t value) +{ + EFI_ENTRY("%p, %ld, 0x%x", buffer, size, value); + memset(buffer, value, size); +} + +static efi_status_t EFIAPI efi_open_protocol( + void *handle, efi_guid_t *protocol, + void **protocol_interface, void *agent_handle, + void *controller_handle, uint32_t attributes) +{ + struct list_head *lhandle; + int i; + efi_status_t r = EFI_UNSUPPORTED; + + EFI_ENTRY("%p, %p, %p, %p, %p, 0x%x", handle, protocol, + protocol_interface, agent_handle, controller_handle, + attributes); + list_for_each(lhandle, &efi_obj_list) { + struct efi_object *efiobj; + efiobj = list_entry(lhandle, struct efi_object, link); + + if (efiobj->handle != handle) + continue; + + for (i = 0; i < ARRAY_SIZE(efiobj->protocols); i++) { + struct efi_handler *handler = &efiobj->protocols[i]; + const efi_guid_t *hprotocol = handler->guid; + if (!hprotocol) + break; + if (!guidcmp(hprotocol, protocol)) { + r = handler->open(handle, protocol, + protocol_interface, agent_handle, + controller_handle, attributes); + goto out; + } + } + } + +out: + return EFI_EXIT(r); +} + +static efi_status_t EFIAPI efi_handle_protocol(void *handle, + efi_guid_t *protocol, + void **protocol_interface) +{ + EFI_ENTRY("%p, %p, %p", handle, protocol, protocol_interface); + return efi_open_protocol(handle, protocol, protocol_interface, + NULL, NULL, 0); +} + +static const struct efi_boot_services efi_boot_services = { + .hdr = { + .headersize = sizeof(struct efi_table_hdr), + }, + .raise_tpl = efi_raise_tpl, + .restore_tpl = efi_restore_tpl, + .allocate_pages = efi_allocate_pages_ext, + .free_pages = efi_free_pages_ext, + .get_memory_map = efi_get_memory_map_ext, + .allocate_pool = efi_allocate_pool, + .free_pool = efi_free_pool, + .create_event = efi_create_event, + .set_timer = efi_set_timer, + .wait_for_event = efi_wait_for_event, + .signal_event = efi_signal_event, + .close_event = efi_close_event, + .check_event = efi_check_event, + .install_protocol_interface = efi_install_protocol_interface, + .reinstall_protocol_interface = efi_reinstall_protocol_interface, + .uninstall_protocol_interface = efi_uninstall_protocol_interface, + .handle_protocol = efi_handle_protocol, + .reserved = NULL, + .register_protocol_notify = efi_register_protocol_notify, + .locate_handle = efi_locate_handle, + .locate_device_path = efi_locate_device_path, + .install_configuration_table = efi_install_configuration_table, + .load_image = efi_load_image, + .start_image = efi_start_image, + .exit = (void*)efi_exit, + .unload_image = efi_unload_image, + .exit_boot_services = efi_exit_boot_services, + .get_next_monotonic_count = efi_get_next_monotonic_count, + .stall = efi_stall, + .set_watchdog_timer = efi_set_watchdog_timer, + .connect_controller = efi_connect_controller, + .disconnect_controller = efi_disconnect_controller, + .open_protocol = efi_open_protocol, + .close_protocol = efi_close_protocol, + .open_protocol_information = efi_open_protocol_information, + .protocols_per_handle = efi_protocols_per_handle, + .locate_handle_buffer = efi_locate_handle_buffer, + .locate_protocol = efi_locate_protocol, + .install_multiple_protocol_interfaces = efi_install_multiple_protocol_interfaces, + .uninstall_multiple_protocol_interfaces = efi_uninstall_multiple_protocol_interfaces, + .calculate_crc32 = efi_calculate_crc32, + .copy_mem = efi_copy_mem, + .set_mem = efi_set_mem, +}; + + +static uint16_t firmware_vendor[] = + { 'D','a','s',' ','U','-','b','o','o','t',0 }; + +struct efi_system_table systab = { + .hdr = { + .signature = EFI_SYSTEM_TABLE_SIGNATURE, + .revision = 0x20005, /* 2.5 */ + .headersize = sizeof(struct efi_table_hdr), + }, + .fw_vendor = (long)firmware_vendor, + .con_in = (void*)&efi_con_in, + .con_out = (void*)&efi_con_out, + .std_err = (void*)&efi_con_out, + .runtime = (void*)&efi_runtime_services, + .boottime = (void*)&efi_boot_services, + .nr_tables = 0, + .tables = (void*)efi_conf_table, +};

After booting has finished, EFI allows firmware to still interact with the OS using the "runtime services". These callbacks live in a separate address space, since they are available long after U-Boot has been overwritten by the OS.

This patch adds enough framework for arbitrary code inside of U-Boot to become a runtime service with the right section attributes set. For now, we don't make use of it yet though.

We could maybe in the future map U-boot environment variables to EFI variables here.

Signed-off-by: Alexander Graf agraf@suse.de Reviewed-by: Simon Glass sjg@chromium.org Tested-by: Simon Glass sjg@chromium.org

---

v1 -> v2:

- Fix runtime service sections - Add runtime detach - Enable runtime relocations - Add get_time - Fix relocation - Fix 32bit - Add am335x support - Move section definition to header - Add systab to runtime section - Add self-relocation hook table - Fix self-relocation - Relocate efi_runtime section early during bootup - Fix return values for a number of callbacks to be more UEFI compliant - Move to GPLv2+

v2 -> v3:

- Patch reset to NULL - Add EFIAPI to function prototypes - Document header - Add dm.h include - Remove non-dm rtc support - Return DEVICE_ERROR in rtc path --- arch/arm/config.mk | 4 + arch/arm/cpu/armv8/u-boot.lds | 16 +++ arch/arm/cpu/u-boot.lds | 30 +++++ arch/arm/lib/sections.c | 4 + board/ti/am335x/u-boot.lds | 30 +++++ common/board_r.c | 4 + include/efi_loader.h | 17 +++ lib/efi_loader/efi_boottime.c | 6 +- lib/efi_loader/efi_runtime.c | 290 ++++++++++++++++++++++++++++++++++++++++++ 9 files changed, 398 insertions(+), 3 deletions(-) create mode 100644 lib/efi_loader/efi_runtime.c

diff --git a/arch/arm/config.mk b/arch/arm/config.mk index 8fa57ec..9af6c37 100644 --- a/arch/arm/config.mk +++ b/arch/arm/config.mk @@ -122,6 +122,10 @@ ifdef CONFIG_OF_EMBED OBJCOPYFLAGS += -j .dtb.init.rodata endif

+ifdef CONFIG_EFI_LOADER +OBJCOPYFLAGS += -j .efi_runtime -j .efi_runtime_rel +endif + ifneq ($(CONFIG_IMX_CONFIG),) ifdef CONFIG_SPL ifndef CONFIG_SPL_BUILD diff --git a/arch/arm/cpu/armv8/u-boot.lds b/arch/arm/cpu/armv8/u-boot.lds index 4c12222..fd15ad5 100644 --- a/arch/arm/cpu/armv8/u-boot.lds +++ b/arch/arm/cpu/armv8/u-boot.lds @@ -42,6 +42,22 @@ SECTIONS

. = ALIGN(8);

+ .efi_runtime : { + __efi_runtime_start = .; + *(efi_runtime_text) + *(efi_runtime_data) + __efi_runtime_stop = .; + } + + .efi_runtime_rel : { + __efi_runtime_rel_start = .; + *(.relaefi_runtime_text) + *(.relaefi_runtime_data) + __efi_runtime_rel_stop = .; + } + + . = ALIGN(8); + .image_copy_end : { *(.__image_copy_end) diff --git a/arch/arm/cpu/u-boot.lds b/arch/arm/cpu/u-boot.lds index e148ab7..13aa4fa 100644 --- a/arch/arm/cpu/u-boot.lds +++ b/arch/arm/cpu/u-boot.lds @@ -90,6 +90,36 @@ SECTIONS

. = ALIGN(4);

+ .__efi_runtime_start : { + *(.__efi_runtime_start) + } + + .efi_runtime : { + *(efi_runtime_text) + *(efi_runtime_data) + } + + .__efi_runtime_stop : { + *(.__efi_runtime_stop) + } + + .efi_runtime_rel_start : + { + *(.__efi_runtime_rel_start) + } + + .efi_runtime_rel : { + *(.relefi_runtime_text) + *(.relefi_runtime_data) + } + + .efi_runtime_rel_stop : + { + *(.__efi_runtime_rel_stop) + } + + . = ALIGN(4); + .image_copy_end : { *(.__image_copy_end) diff --git a/arch/arm/lib/sections.c b/arch/arm/lib/sections.c index a1205c3..6a94522 100644 --- a/arch/arm/lib/sections.c +++ b/arch/arm/lib/sections.c @@ -27,4 +27,8 @@ char __rel_dyn_start[0] __attribute__((section(".__rel_dyn_start"))); char __rel_dyn_end[0] __attribute__((section(".__rel_dyn_end"))); char __secure_start[0] __attribute__((section(".__secure_start"))); char __secure_end[0] __attribute__((section(".__secure_end"))); +char __efi_runtime_start[0] __attribute__((section(".__efi_runtime_start"))); +char __efi_runtime_stop[0] __attribute__((section(".__efi_runtime_stop"))); +char __efi_runtime_rel_start[0] __attribute__((section(".__efi_runtime_rel_start"))); +char __efi_runtime_rel_stop[0] __attribute__((section(".__efi_runtime_rel_stop"))); char _end[0] __attribute__((section(".__end"))); diff --git a/board/ti/am335x/u-boot.lds b/board/ti/am335x/u-boot.lds index 78f294a..a56cc82 100644 --- a/board/ti/am335x/u-boot.lds +++ b/board/ti/am335x/u-boot.lds @@ -59,6 +59,36 @@ SECTIONS

. = ALIGN(4);

+ .__efi_runtime_start : { + *(.__efi_runtime_start) + } + + .efi_runtime : { + *(efi_runtime_text) + *(efi_runtime_data) + } + + .__efi_runtime_stop : { + *(.__efi_runtime_stop) + } + + .efi_runtime_rel_start : + { + *(.__efi_runtime_rel_start) + } + + .efi_runtime_rel : { + *(.relefi_runtime_text) + *(.relefi_runtime_data) + } + + .efi_runtime_rel_stop : + { + *(.__efi_runtime_rel_stop) + } + + . = ALIGN(4); + .image_copy_end : { *(.__image_copy_end) diff --git a/common/board_r.c b/common/board_r.c index 6c23865..e7e7968 100644 --- a/common/board_r.c +++ b/common/board_r.c @@ -64,6 +64,7 @@ #ifdef CONFIG_AVR32 #include <asm/arch/mmu.h> #endif +#include <efi_loader.h>

DECLARE_GLOBAL_DATA_PTR;

@@ -176,6 +177,9 @@ static int initr_reloc_global_data(void) */ gd->fdt_blob += gd->reloc_off; #endif +#ifdef CONFIG_EFI_LOADER + efi_runtime_relocate(gd->relocaddr, NULL); +#endif

return 0; } diff --git a/include/efi_loader.h b/include/efi_loader.h index b4e82ac..3a71a77 100644 --- a/include/efi_loader.h +++ b/include/efi_loader.h @@ -29,6 +29,7 @@

#define EFI_EXIT(ret) efi_exit_func(ret);

+extern struct efi_runtime_services efi_runtime_services; extern struct efi_system_table systab;

extern const struct efi_simple_text_output_protocol efi_con_out; @@ -39,6 +40,9 @@ extern const efi_guid_t efi_guid_console_control; extern const efi_guid_t efi_guid_device_path; extern const efi_guid_t efi_guid_loaded_image;

+extern unsigned int __efi_runtime_start, __efi_runtime_stop; +extern unsigned int __efi_runtime_rel_start, __efi_runtime_rel_stop; + /* * While UEFI objects can have callbacks, you can also call functions on * protocols (classes) themselves. This struct maps a protocol GUID to its @@ -100,9 +104,22 @@ void efi_save_gd(void); void efi_restore_gd(void); /* Called from EFI_EXIT on callback exit to restore the gd register */ efi_status_t efi_exit_func(efi_status_t ret); +/* Call this to relocate the runtime section to an address space */ +void efi_runtime_relocate(ulong offset, struct efi_mem_desc *map); + +/* + * Use these to indicate that your code / data should go into the EFI runtime + * section and thus still be available when the OS is running + */ +#define EFI_RUNTIME_DATA __attribute__ ((section ("efi_runtime_data"))) +#define EFI_RUNTIME_TEXT __attribute__ ((section ("efi_runtime_text")))

#else /* defined(EFI_LOADER) */

+/* Without CONFIG_EFI_LOADER we don't have a runtime section, stub it out */ +#define EFI_RUNTIME_DATA +#define EFI_RUNTIME_TEXT + /* No loader configured, stub out EFI_ENTRY */ static inline void efi_restore_gd(void) { }

diff --git a/lib/efi_loader/efi_boottime.c b/lib/efi_loader/efi_boottime.c index e60fae9..87400de 100644 --- a/lib/efi_loader/efi_boottime.c +++ b/lib/efi_loader/efi_boottime.c @@ -39,7 +39,7 @@ static bool efi_is_direct_boot = true; * In most cases we want to pass an FDT to the payload, so reserve one slot of * config table space for it. The pointer gets populated by do_bootefi_exec(). */ -static struct efi_configuration_table efi_conf_table[1]; +static struct efi_configuration_table EFI_RUNTIME_DATA efi_conf_table[1];

/* * The "gd" pointer lives in a register on ARM and AArch64 that we declare @@ -761,10 +761,10 @@ static const struct efi_boot_services efi_boot_services = { };

-static uint16_t firmware_vendor[] = +static uint16_t EFI_RUNTIME_DATA firmware_vendor[] = { 'D','a','s',' ','U','-','b','o','o','t',0 };

-struct efi_system_table systab = { +struct efi_system_table EFI_RUNTIME_DATA systab = { .hdr = { .signature = EFI_SYSTEM_TABLE_SIGNATURE, .revision = 0x20005, /* 2.5 */ diff --git a/lib/efi_loader/efi_runtime.c b/lib/efi_loader/efi_runtime.c new file mode 100644 index 0000000..22bcd08 --- /dev/null +++ b/lib/efi_loader/efi_runtime.c @@ -0,0 +1,290 @@ +/* + * EFI application runtime services + * + * Copyright (c) 2016 Alexander Graf + * + * SPDX-License-Identifier: GPL-2.0+ + */ + +#include <common.h> +#include <command.h> +#include <dm.h> +#include <efi_loader.h> +#include <rtc.h> +#include <asm/global_data.h> + +/* For manual relocation support */ +DECLARE_GLOBAL_DATA_PTR; + +static efi_status_t EFI_RUNTIME_TEXT EFIAPI efi_unimplemented(void); +static efi_status_t EFI_RUNTIME_TEXT EFIAPI efi_device_error(void); +static efi_status_t EFI_RUNTIME_TEXT EFIAPI efi_invalid_parameter(void); + +#if defined(CONFIG_ARM64) +#define R_RELATIVE 1027 +#define R_MASK 0xffffffffULL +#define IS_RELA 1 +#elif defined(CONFIG_ARM) +#define R_RELATIVE 23 +#define R_MASK 0xffULL +#else +#error Need to add relocation awareness +#endif + +struct elf_rel { + ulong *offset; + ulong info; +}; + +struct elf_rela { + ulong *offset; + ulong info; + long addend; +}; + +/* + * EFI Runtime code lives in 2 stages. In the first stage, U-Boot and an EFI + * payload are running concurrently at the same time. In this mode, we can + * handle a good number of runtime callbacks + */ + +static void EFIAPI efi_reset_system(enum efi_reset_type reset_type, + efi_status_t reset_status, + unsigned long data_size, void *reset_data) +{ + EFI_ENTRY("%d %lx %lx %p", reset_type, reset_status, data_size, + reset_data); + + switch (reset_type) { + case EFI_RESET_COLD: + case EFI_RESET_WARM: + do_reset(NULL, 0, 0, NULL); + break; + case EFI_RESET_SHUTDOWN: + /* We don't have anything to map this to */ + break; + } + + EFI_EXIT(EFI_SUCCESS); +} + +static efi_status_t EFIAPI efi_get_time(struct efi_time *time, + struct efi_time_cap *capabilities) +{ +#if defined(CONFIG_CMD_DATE) && defined(CONFIG_DM_RTC) + struct rtc_time tm; + int r; + struct udevice *dev; + + EFI_ENTRY("%p %p", time, capabilities); + + r = uclass_get_device(UCLASS_RTC, 0, &dev); + if (r) + return EFI_EXIT(EFI_DEVICE_ERROR); + + r = dm_rtc_get(dev, &tm); + if (r) + return EFI_EXIT(EFI_DEVICE_ERROR); + + memset(time, 0, sizeof(*time)); + time->year = tm.tm_year; + time->month = tm.tm_mon; + time->day = tm.tm_mday; + time->hour = tm.tm_hour; + time->minute = tm.tm_min; + time->daylight = tm.tm_isdst; + + return EFI_EXIT(EFI_SUCCESS); +#else + return EFI_DEVICE_ERROR; +#endif +} + +struct efi_runtime_detach_list_struct { + void *ptr; + void *patchto; +}; + +static const struct efi_runtime_detach_list_struct efi_runtime_detach_list[] = { + { + /* do_reset is gone */ + .ptr = &efi_runtime_services.reset_system, + .patchto = NULL, + }, { + /* invalidate_*cache_all are gone */ + .ptr = &efi_runtime_services.set_virtual_address_map, + .patchto = &efi_invalid_parameter, + }, { + /* RTC accessors are gone */ + .ptr = &efi_runtime_services.get_time, + .patchto = &efi_device_error, + }, +}; + +static bool efi_runtime_tobedetached(void *p) +{ + int i; + + for (i = 0; i < ARRAY_SIZE(efi_runtime_detach_list); i++) + if (efi_runtime_detach_list[i].ptr == p) + return true; + + return false; +} + +static void efi_runtime_detach(ulong offset) +{ + int i; + ulong patchoff = offset - (ulong)gd->relocaddr; + + for (i = 0; i < ARRAY_SIZE(efi_runtime_detach_list); i++) { + ulong patchto = (ulong)efi_runtime_detach_list[i].patchto; + ulong *p = efi_runtime_detach_list[i].ptr; + ulong newaddr = patchto ? (patchto + patchoff) : 0; + +#ifdef DEBUG_EFI + printf("%s: Setting %p to %lx\n", __func__, p, newaddr); +#endif + *p = newaddr; + } +} + +/* Relocate EFI runtime to uboot_reloc_base = offset */ +void efi_runtime_relocate(ulong offset, struct efi_mem_desc *map) +{ +#ifdef IS_RELA + struct elf_rela *rel = (void*)&__efi_runtime_rel_start; +#else + struct elf_rel *rel = (void*)&__efi_runtime_rel_start; + static ulong lastoff = CONFIG_SYS_TEXT_BASE; +#endif + +#ifdef DEBUG_EFI + printf("%s: Relocating to offset=%lx\n", __func__, offset); +#endif + + for (; (ulong)rel < (ulong)&__efi_runtime_rel_stop; rel++) { + ulong base = CONFIG_SYS_TEXT_BASE; + ulong *p; + ulong newaddr; + + p = (void*)((ulong)rel->offset - base) + gd->relocaddr; + + if ((rel->info & R_MASK) != R_RELATIVE) { + continue; + } + +#ifdef IS_RELA + newaddr = rel->addend + offset - CONFIG_SYS_TEXT_BASE; +#else + newaddr = *p - lastoff + offset; +#endif + + /* Check if the relocation is inside bounds */ + if (map && ((newaddr < map->virtual_start) || + newaddr > (map->virtual_start + (map->num_pages << 12)))) { + if (!efi_runtime_tobedetached(p)) + printf("U-Boot EFI: Relocation at %p is out of " + "range (%lx)\n", p, newaddr); + continue; + } + +#ifdef DEBUG_EFI + printf("%s: Setting %p to %lx\n", __func__, p, newaddr); +#endif + + *p = newaddr; + flush_dcache_range((ulong)p, (ulong)&p[1]); + } + +#ifndef IS_RELA + lastoff = offset; +#endif + + invalidate_icache_all(); +} + +static efi_status_t EFIAPI efi_set_virtual_address_map( + unsigned long memory_map_size, + unsigned long descriptor_size, + uint32_t descriptor_version, + struct efi_mem_desc *virtmap) +{ + ulong runtime_start = (ulong)&__efi_runtime_start & ~0xfffULL; + int n = memory_map_size / descriptor_size; + int i; + + EFI_ENTRY("%lx %lx %x %p", memory_map_size, descriptor_size, + descriptor_version, virtmap); + + for (i = 0; i < n; i++) { + struct efi_mem_desc *map; + + map = (void*)virtmap + (descriptor_size * i); + if (map->type == EFI_RUNTIME_SERVICES_CODE) { + ulong new_offset = map->virtual_start - (runtime_start - gd->relocaddr); + + efi_runtime_relocate(new_offset, map); + /* Once we're virtual, we can no longer handle + complex callbacks */ + efi_runtime_detach(new_offset); + return EFI_EXIT(EFI_SUCCESS); + } + } + + return EFI_EXIT(EFI_INVALID_PARAMETER); +} + +/* + * In the second stage, U-Boot has disappeared. To isolate our runtime code + * that at this point still exists from the rest, we put it into a special + * section. + * + * !!WARNING!! + * + * This means that we can not rely on any code outside of this file in any + * function or variable below this line. + * + * Please keep everything fully self-contained and annotated with + * EFI_RUNTIME_TEXT and EFI_RUNTIME_DATA markers. + */ + +/* + * Relocate the EFI runtime stub to a different place. We need to call this + * the first time we expose the runtime interface to a user and on set virtual + * address map calls. + */ + +static efi_status_t EFI_RUNTIME_TEXT EFIAPI efi_unimplemented(void) +{ + return EFI_UNSUPPORTED; +} + +static efi_status_t EFI_RUNTIME_TEXT EFIAPI efi_device_error(void) +{ + return EFI_DEVICE_ERROR; +} + +static efi_status_t EFI_RUNTIME_TEXT EFIAPI efi_invalid_parameter(void) +{ + return EFI_INVALID_PARAMETER; +} + +struct efi_runtime_services EFI_RUNTIME_DATA efi_runtime_services = { + .hdr = { + .signature = EFI_RUNTIME_SERVICES_SIGNATURE, + .revision = EFI_RUNTIME_SERVICES_REVISION, + .headersize = sizeof(struct efi_table_hdr), + }, + .get_time = &efi_get_time, + .set_time = (void *)&efi_device_error, + .get_wakeup_time = (void *)&efi_unimplemented, + .set_wakeup_time = (void *)&efi_unimplemented, + .set_virtual_address_map = &efi_set_virtual_address_map, + .convert_pointer = (void *)&efi_invalid_parameter, + .get_variable = (void *)&efi_device_error, + .get_next_variable = (void *)&efi_device_error, + .set_variable = (void *)&efi_device_error, + .get_next_high_mono_count = (void *)&efi_device_error, + .reset_system = &efi_reset_system, +};

In order to execute an EFI application, we need to bridge the gap between U-Boot's notion of executing images and EFI's notion of doing the same.

The best path forward IMHO here is to stick completely to the way U-Boot deals with payloads. You manually load them using whatever method to RAM and then have a simple boot command to execute them. So in our case, you would do

# load mmc 0:1 $loadaddr grub.efi # bootefi $loadaddr

which then gets you into a grub shell. Fdt information known to U-boot via the fdt addr command is also passed to the EFI payload.

Signed-off-by: Alexander Graf agraf@suse.de Reviewed-by: Simon Glass sjg@chromium.org Tested-by: Simon Glass sjg@chromium.org

---

v1 -> v2:

- Move to GPLv2+

v2 -> v3:

- Move to new cmd directory - Add kconfig option - Fix comment style - Add help text - s/-1/-ENOENT - Move obj list to lib

XXX bootefi: make dtb conf table more explicit --- cmd/Kconfig | 7 +++ cmd/Makefile | 1 + cmd/bootefi.c | 167 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 175 insertions(+) create mode 100644 cmd/bootefi.c

diff --git a/cmd/Kconfig b/cmd/Kconfig index 2ed0263..7cdff04 100644 --- a/cmd/Kconfig +++ b/cmd/Kconfig @@ -148,6 +148,13 @@ config CMD_BOOTM help Boot an application image from the memory.

+config CMD_BOOTEFI + bool "bootefi" + depends on EFI_LOADER + default y + help + Boot an EFI image from memory. + config CMD_ELF bool "bootelf, bootvx" default y diff --git a/cmd/Makefile b/cmd/Makefile index 03f7e0a..7604621 100644 --- a/cmd/Makefile +++ b/cmd/Makefile @@ -21,6 +21,7 @@ obj-$(CONFIG_CMD_SOURCE) += source.o obj-$(CONFIG_CMD_BDI) += bdinfo.o obj-$(CONFIG_CMD_BEDBUG) += bedbug.o obj-$(CONFIG_CMD_BMP) += bmp.o +obj-$(CONFIG_CMD_BOOTEFI) += bootefi.o obj-$(CONFIG_CMD_BOOTMENU) += bootmenu.o obj-$(CONFIG_CMD_BOOTLDR) += bootldr.o obj-$(CONFIG_CMD_BOOTSTAGE) += bootstage.o diff --git a/cmd/bootefi.c b/cmd/bootefi.c new file mode 100644 index 0000000..e3e51d4 --- /dev/null +++ b/cmd/bootefi.c @@ -0,0 +1,167 @@ +/* + * EFI application loader + * + * Copyright (c) 2016 Alexander Graf + * + * SPDX-License-Identifier: GPL-2.0+ + */ + +#include <common.h> +#include <command.h> +#include <efi_loader.h> +#include <errno.h> +#include <libfdt_env.h> + +/* + * When booting using the "bootefi" command, we don't know which + * physical device the file came from. So we create a pseudo-device + * called "bootefi" with the device path /bootefi. + * + * In addition to the originating device we also declare the file path + * of "bootefi" based loads to be /bootefi. + */ +static struct efi_device_path_file_path bootefi_dummy_path[] = { + { + .dp.type = DEVICE_PATH_TYPE_MEDIA_DEVICE, + .dp.sub_type = DEVICE_PATH_SUB_TYPE_FILE_PATH, + .dp.length = sizeof(bootefi_dummy_path[0]), + .str = { 'b','o','o','t','e','f','i' }, + }, { + .dp.type = DEVICE_PATH_TYPE_END, + .dp.sub_type = DEVICE_PATH_SUB_TYPE_END, + .dp.length = sizeof(bootefi_dummy_path[0]), + } +}; + +static efi_status_t bootefi_open_dp(void *handle, efi_guid_t *protocol, + void **protocol_interface, void *agent_handle, + void *controller_handle, uint32_t attributes) +{ + *protocol_interface = bootefi_dummy_path; + return EFI_SUCCESS; +} + +/* The EFI loaded_image interface for the image executed via "bootefi" */ +static struct efi_loaded_image loaded_image_info = { + .device_handle = bootefi_dummy_path, + .file_path = bootefi_dummy_path, +}; + +/* The EFI object struct for the image executed via "bootefi" */ +static struct efi_object loaded_image_info_obj = { + .handle = &loaded_image_info, + .protocols = { + { + /* + * When asking for the loaded_image interface, just + * return handle which points to loaded_image_info + */ + .guid = &efi_guid_loaded_image, + .open = &efi_return_handle, + }, + { + /* + * When asking for the device path interface, return + * bootefi_dummy_path + */ + .guid = &efi_guid_device_path, + .open = &bootefi_open_dp, + }, + }, +}; + +/* The EFI object struct for the device the "bootefi" image was loaded from */ +static struct efi_object bootefi_device_obj = { + .handle = bootefi_dummy_path, + .protocols = { + { + /* When asking for the device path interface, return + * bootefi_dummy_path */ + .guid = &efi_guid_device_path, + .open = &bootefi_open_dp, + } + }, +}; + +/* + * Load an EFI payload into a newly allocated piece of memory, register all + * EFI objects it would want to access and jump to it. + */ +static unsigned long do_bootefi_exec(void *efi) +{ + ulong (*entry)(void *image_handle, struct efi_system_table *st); + + /* + * gd lives in a fixed register which may get clobbered while we execute + * the payload. So save it here and restore it on every callback entry + */ + efi_save_gd(); + + /* Update system table to point to our currently loaded FDT */ + + if (working_fdt) { + systab.tables[0].guid = EFI_FDT_GUID; + systab.tables[0].table = working_fdt; + systab.nr_tables = 1; + } else { + printf("WARNING: No device tree loaded, expect boot to fail\n"); + systab.nr_tables = 0; + } + + /* Load the EFI payload */ + entry = efi_load_pe(efi, &loaded_image_info); + if (!entry) + return -ENOENT; + + /* Initialize and populate EFI object list */ + INIT_LIST_HEAD(&efi_obj_list); + list_add_tail(&loaded_image_info_obj.link, &efi_obj_list); + list_add_tail(&bootefi_device_obj.link, &efi_obj_list); +#ifdef CONFIG_PARTITIONS + efi_disk_register(); +#endif + + /* Call our payload! */ +#ifdef DEBUG_EFI + printf("%s:%d Jumping to 0x%lx\n", __func__, __LINE__, (long)entry); +#endif + return entry(&loaded_image_info, &systab); +} + + +/* Interpreter command to boot an arbitrary EFI image from memory */ +static int do_bootefi(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) +{ + char *saddr; + unsigned long addr; + int r = 0; + + if (argc < 2) + return 1; + saddr = argv[1]; + + addr = simple_strtoul(saddr, NULL, 16); + + printf("## Starting EFI application at 0x%08lx ...\n", addr); + r = do_bootefi_exec((void *)addr); + printf("## Application terminated, r = %d\n", r); + + if (r != 0) + r = 1; + + return r; +} + +static char bootefi_help_text[] = + "<image address>\n" + " - boot EFI payload stored at address <image address>\n" + "\n" + "Since most EFI payloads want to have a device tree provided, please\n" + "make sure you load a device tree using the fdt addr command before\n" + "executing bootefi.\n"; + +U_BOOT_CMD( + bootefi, 2, 0, do_bootefi, + "Boots an EFI payload from memory\n", + bootefi_help_text +);

Our current arm64 exception handlers all panic and never return to the exception triggering code.

But if any handler wanted to continue execution after fixups, it would need help from the exception handling code to restore all registers.

This patch implements that help. With this code, exception handlers on aarch64 can successfully return to the place the exception happened (or somewhere else if they modify elr).

Signed-off-by: Alexander Graf agraf@suse.de --- arch/arm/cpu/armv8/exceptions.S | 34 ++++++++++++++++++++++++++++++++++ 1 file changed, 34 insertions(+)

diff --git a/arch/arm/cpu/armv8/exceptions.S b/arch/arm/cpu/armv8/exceptions.S index baf9401..4f4f526 100644 --- a/arch/arm/cpu/armv8/exceptions.S +++ b/arch/arm/cpu/armv8/exceptions.S @@ -82,31 +82,65 @@ vectors: _do_bad_sync: exception_entry bl do_bad_sync + b exception_exit

_do_bad_irq: exception_entry bl do_bad_irq + b exception_exit

_do_bad_fiq: exception_entry bl do_bad_fiq + b exception_exit

_do_bad_error: exception_entry bl do_bad_error + b exception_exit

_do_sync: exception_entry bl do_sync + b exception_exit

_do_irq: exception_entry bl do_irq + b exception_exit

_do_fiq: exception_entry bl do_fiq + b exception_exit

_do_error: exception_entry bl do_error + b exception_exit + +exception_exit: + ldp x2, x0, [sp],#16 + switch_el x11, 3f, 2f, 1f +3: msr elr_el3, x2 + b 0f +2: msr elr_el2, x2 + b 0f +1: msr elr_el1, x2 +0: + ldp x1, x2, [sp],#16 + ldp x3, x4, [sp],#16 + ldp x5, x6, [sp],#16 + ldp x7, x8, [sp],#16 + ldp x9, x10, [sp],#16 + ldp x11, x12, [sp],#16 + ldp x13, x14, [sp],#16 + ldp x15, x16, [sp],#16 + ldp x17, x18, [sp],#16 + ldp x19, x20, [sp],#16 + ldp x21, x22, [sp],#16 + ldp x23, x24, [sp],#16 + ldp x25, x26, [sp],#16 + ldp x27, x28, [sp],#16 + ldp x29, x30, [sp],#16 + eret

Now that we have all the bits and pieces ready for EFI payload loading support, hook them up in Makefiles and KConfigs so that we can build.

Signed-off-by: Alexander Graf agraf@suse.de Reviewed-by: Simon Glass sjg@chromium.org Tested-by: Simon Glass sjg@chromium.org

---

v1 -> v2:

- Move to GPLv2+ - Default to y

v2 -> v3:

- Add memory file --- lib/Kconfig | 1 + lib/Makefile | 1 + lib/efi_loader/Kconfig | 9 +++++++++ lib/efi_loader/Makefile | 12 ++++++++++++ 4 files changed, 23 insertions(+) create mode 100644 lib/efi_loader/Kconfig create mode 100644 lib/efi_loader/Makefile

diff --git a/lib/Kconfig b/lib/Kconfig index c7eab46..a67df3c 100644 --- a/lib/Kconfig +++ b/lib/Kconfig @@ -129,5 +129,6 @@ config ERRNO_STR - if errno is negative - a pointer to errno related message

source lib/efi/Kconfig +source lib/efi_loader/Kconfig

endmenu diff --git a/lib/Makefile b/lib/Makefile index 1e21bcc..4aaa2ea 100644 --- a/lib/Makefile +++ b/lib/Makefile @@ -8,6 +8,7 @@ ifndef CONFIG_SPL_BUILD

obj-$(CONFIG_EFI) += efi/ +obj-$(CONFIG_EFI_LOADER) += efi_loader/ obj-$(CONFIG_RSA) += rsa/ obj-$(CONFIG_LZMA) += lzma/ obj-$(CONFIG_LZO) += lzo/ diff --git a/lib/efi_loader/Kconfig b/lib/efi_loader/Kconfig new file mode 100644 index 0000000..6da1c7f --- /dev/null +++ b/lib/efi_loader/Kconfig @@ -0,0 +1,9 @@ +config EFI_LOADER + bool "Support running EFI Applications in U-Boot" + depends on ARM64 || ARM + default y + help + Select this option if you want to run EFI applications (like grub2) + on top of U-Boot. If this option is enabled, U-Boot will expose EFI + interfaces to a loaded EFI application, enabling it to reuse U-Boot's + device drivers. diff --git a/lib/efi_loader/Makefile b/lib/efi_loader/Makefile new file mode 100644 index 0000000..28725a2 --- /dev/null +++ b/lib/efi_loader/Makefile @@ -0,0 +1,12 @@ +# +# (C) Copyright 2016 Alexander Graf +# +# SPDX-License-Identifier: GPL-2.0+ +# + +# This file only gets included with CONFIG_EFI_LOADER set, so all +# object inclusion implicitly depends on it + +obj-y += efi_image_loader.o efi_boottime.o efi_runtime.o efi_console.o +obj-y += efi_memory.o +obj-$(CONFIG_PARTITIONS) += efi_disk.o

To preserve all cover letter knowledge of the status on UEFI payload support, let's add some sections to README.efi.

Signed-off-by: Alexander Graf agraf@suse.de

v3 -> v4:

- Add section about config options - s/10kb/10KB/ --- doc/README.efi | 83 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 82 insertions(+), 1 deletion(-)

diff --git a/doc/README.efi b/doc/README.efi index 23a3cdd..1fd3f00 100644 --- a/doc/README.efi +++ b/doc/README.efi @@ -4,6 +4,28 @@ # SPDX-License-Identifier: GPL-2.0+ #

+=========== Table of Contents =========== + + 1 U-Boot on EFI + 1.1 In God's Name, Why? + 1.2 Status + 1.3 Build Instructions + 1.4 Trying it out + 1.5 Inner workings + 1.6 EFI Application + 1.7 EFI Payload + 1.8 Tables + 1.9 Interrupts + 1.10 32/64-bit + 1.11 Future work + 1.12 Where is the code? + + 2 EFI on U-Boot + 2.1 In God's Name, Why? + 2.2 How do I get it? + 2.3 Status + 2.4 Future work + U-Boot on EFI ============= This document provides information about U-Boot running on top of EFI, either @@ -234,7 +256,6 @@ board/efi/efi-x86/efi.c common/cmd_efi.c the 'efi' command

- -- Ben Stoltz, Simon Glass Google, Inc @@ -242,3 +263,63 @@ July 2015

[1] http://www.qemu.org [2] http://www.tianocore.org/ovmf/ + +------------------------------------------------------------------------------- + +EFI on U-Boot +============= + +In addition to support for running U-Boot as a UEFI application, U-Boot itself +can also expose the UEFI interfaces and thus allow UEFI payloads to run under +it. + +In God's Name, Why? +------------------- + +With this support in place, you can run any UEFI payload (such as the Linux +kernel, grub2 or gummiboot) on U-Boot. This dramatically simplifies boot loader +configuration, as U-Boot based systems now look and feel (almost) the same way +as TianoCore based systems. + +How do I get it? +---------------- + +EFI support for 32bit ARM and AArch64 is already included in U-Boot. All you +need to do is enable + + CONFIG_CMD_BOOTEFI=y + CONFIG_EFI_LOADER=y + +in your .config file and you will automatically get a bootefi command to run +an efi application as well as snippet in the default distro boot script that +scans for removable media efi binaries as fallback. + +Status +------ + +I am successfully able to run grub2 and Linux EFI binaries with this code on +ARMv7 as well as AArch64 systems. + +When enabled, the resulting U-Boot binary only grows by ~10KB, so it's very +light weight. + +All storage devices are directly accessible from the uEFI payload + +Removable media booting (search for /efi/boot/boota{a64,arm}.efi) is supported. + +Simple use cases like "Plug this SD card into my ARM device and it just +boots into grub which boots into Linux", work very well. + +Future work +----------- + +Of course, there are still a few things one could do on top: + + - Improve disk media detection (don't scan, use what information we +have) + - Add EFI variable support using NVRAM + - Add GFX support + - Make EFI Shell work + - Network device support + - Support for payload exit + - Payload Watchdog support