2016-03-04 08:09:58 +08:00
|
|
|
/*
|
|
|
|
* EFI application loader
|
|
|
|
*
|
|
|
|
* Copyright (c) 2016 Alexander Graf
|
|
|
|
*
|
|
|
|
* SPDX-License-Identifier: GPL-2.0+
|
|
|
|
*/
|
|
|
|
|
2017-10-19 00:13:07 +08:00
|
|
|
#ifndef _EFI_LOADER_H
|
|
|
|
#define _EFI_LOADER_H 1
|
|
|
|
|
2016-03-04 08:09:59 +08:00
|
|
|
#include <common.h>
|
2016-03-04 08:09:58 +08:00
|
|
|
#include <part_efi.h>
|
|
|
|
#include <efi_api.h>
|
2016-03-04 08:09:59 +08:00
|
|
|
|
|
|
|
/* No need for efi loader support in SPL */
|
|
|
|
#if defined(CONFIG_EFI_LOADER) && !defined(CONFIG_SPL_BUILD)
|
|
|
|
|
2016-03-04 08:09:58 +08:00
|
|
|
#include <linux/list.h>
|
|
|
|
|
2017-07-27 20:04:18 +08:00
|
|
|
int __efi_entry_check(void);
|
|
|
|
int __efi_exit_check(void);
|
2017-08-18 23:45:16 +08:00
|
|
|
const char *__efi_nesting(void);
|
2017-07-27 20:04:19 +08:00
|
|
|
const char *__efi_nesting_inc(void);
|
|
|
|
const char *__efi_nesting_dec(void);
|
2017-07-27 20:04:18 +08:00
|
|
|
|
2017-07-27 20:04:17 +08:00
|
|
|
/*
|
|
|
|
* Enter the u-boot world from UEFI:
|
|
|
|
*/
|
2016-03-04 08:09:59 +08:00
|
|
|
#define EFI_ENTRY(format, ...) do { \
|
2017-07-27 20:04:18 +08:00
|
|
|
assert(__efi_entry_check()); \
|
2017-07-27 20:04:19 +08:00
|
|
|
debug("%sEFI: Entry %s(" format ")\n", __efi_nesting_inc(), \
|
|
|
|
__func__, ##__VA_ARGS__); \
|
2016-03-04 08:09:59 +08:00
|
|
|
} while(0)
|
|
|
|
|
2017-07-27 20:04:17 +08:00
|
|
|
/*
|
|
|
|
* Exit the u-boot world back to UEFI:
|
|
|
|
*/
|
2017-07-24 22:31:52 +08:00
|
|
|
#define EFI_EXIT(ret) ({ \
|
2017-08-18 00:57:36 +08:00
|
|
|
typeof(ret) _r = ret; \
|
2017-07-27 20:04:19 +08:00
|
|
|
debug("%sEFI: Exit: %s: %u\n", __efi_nesting_dec(), \
|
2017-08-18 00:57:36 +08:00
|
|
|
__func__, (u32)((uintptr_t) _r & ~EFI_ERROR_MASK)); \
|
2017-07-27 20:04:18 +08:00
|
|
|
assert(__efi_exit_check()); \
|
|
|
|
_r; \
|
2017-07-24 22:31:52 +08:00
|
|
|
})
|
2016-03-04 08:09:59 +08:00
|
|
|
|
2017-07-27 20:04:17 +08:00
|
|
|
/*
|
2017-09-15 16:06:10 +08:00
|
|
|
* Call non-void UEFI function from u-boot and retrieve return value:
|
2017-07-27 20:04:17 +08:00
|
|
|
*/
|
2017-09-15 16:06:10 +08:00
|
|
|
#define EFI_CALL(exp) ({ \
|
|
|
|
debug("%sEFI: Call: %s\n", __efi_nesting_inc(), #exp); \
|
|
|
|
assert(__efi_exit_check()); \
|
|
|
|
typeof(exp) _r = exp; \
|
|
|
|
assert(__efi_entry_check()); \
|
|
|
|
debug("%sEFI: %lu returned by %s\n", __efi_nesting_dec(), \
|
|
|
|
(unsigned long)((uintptr_t)_r & ~EFI_ERROR_MASK), #exp); \
|
|
|
|
_r; \
|
|
|
|
})
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Call void UEFI function from u-boot:
|
|
|
|
*/
|
|
|
|
#define EFI_CALL_VOID(exp) do { \
|
2017-07-27 20:04:19 +08:00
|
|
|
debug("%sEFI: Call: %s\n", __efi_nesting_inc(), #exp); \
|
2017-07-27 20:04:18 +08:00
|
|
|
assert(__efi_exit_check()); \
|
2017-07-27 20:04:17 +08:00
|
|
|
exp; \
|
2017-07-27 20:04:18 +08:00
|
|
|
assert(__efi_entry_check()); \
|
2017-07-27 20:04:19 +08:00
|
|
|
debug("%sEFI: Return From: %s\n", __efi_nesting_dec(), #exp); \
|
2017-07-27 20:04:17 +08:00
|
|
|
} while(0)
|
|
|
|
|
2017-08-18 23:45:16 +08:00
|
|
|
/*
|
2018-01-11 15:16:01 +08:00
|
|
|
* Write an indented message with EFI prefix
|
2017-08-18 23:45:16 +08:00
|
|
|
*/
|
2018-01-11 15:16:01 +08:00
|
|
|
#define EFI_PRINT(format, ...) ({ \
|
|
|
|
debug("%sEFI: " format, __efi_nesting(), \
|
|
|
|
##__VA_ARGS__); \
|
2017-08-18 23:45:16 +08:00
|
|
|
})
|
|
|
|
|
2016-03-04 08:10:01 +08:00
|
|
|
extern struct efi_runtime_services efi_runtime_services;
|
2016-03-04 08:09:59 +08:00
|
|
|
extern struct efi_system_table systab;
|
|
|
|
|
2017-10-27 01:25:59 +08:00
|
|
|
extern struct efi_simple_text_output_protocol efi_con_out;
|
2017-07-19 02:17:22 +08:00
|
|
|
extern struct efi_simple_input_interface efi_con_in;
|
2017-10-27 01:25:59 +08:00
|
|
|
extern struct efi_console_control_protocol efi_console_control;
|
2017-07-12 04:06:25 +08:00
|
|
|
extern const struct efi_device_path_to_text_protocol efi_device_path_to_text;
|
2018-03-10 00:43:21 +08:00
|
|
|
/* implementation of the EFI_DEVICE_PATH_UTILITIES_PROTOCOL */
|
|
|
|
extern const struct efi_device_path_utilities_protocol
|
|
|
|
efi_device_path_utilities;
|
2016-03-04 08:10:00 +08:00
|
|
|
|
2017-09-14 06:05:30 +08:00
|
|
|
uint16_t *efi_dp_str(struct efi_device_path *dp);
|
|
|
|
|
2018-01-20 03:24:45 +08:00
|
|
|
/* GUID of the EFI_BLOCK_IO_PROTOCOL */
|
|
|
|
extern const efi_guid_t efi_block_io_guid;
|
2017-09-14 06:05:38 +08:00
|
|
|
extern const efi_guid_t efi_global_variable_guid;
|
2016-03-04 08:10:00 +08:00
|
|
|
extern const efi_guid_t efi_guid_console_control;
|
2016-03-04 08:09:58 +08:00
|
|
|
extern const efi_guid_t efi_guid_device_path;
|
2018-01-11 15:16:02 +08:00
|
|
|
/* GUID of the EFI_DRIVER_BINDING_PROTOCOL */
|
|
|
|
extern const efi_guid_t efi_guid_driver_binding_protocol;
|
2016-03-04 08:09:58 +08:00
|
|
|
extern const efi_guid_t efi_guid_loaded_image;
|
2017-07-12 04:06:25 +08:00
|
|
|
extern const efi_guid_t efi_guid_device_path_to_text_protocol;
|
2017-09-14 06:05:34 +08:00
|
|
|
extern const efi_guid_t efi_simple_file_system_protocol_guid;
|
|
|
|
extern const efi_guid_t efi_file_info_guid;
|
2018-03-10 00:43:21 +08:00
|
|
|
extern const efi_guid_t efi_guid_device_path_utilities_protocol;
|
2016-03-04 08:09:58 +08:00
|
|
|
|
2016-03-04 08:10:01 +08:00
|
|
|
extern unsigned int __efi_runtime_start, __efi_runtime_stop;
|
|
|
|
extern unsigned int __efi_runtime_rel_start, __efi_runtime_rel_stop;
|
|
|
|
|
2018-01-11 15:15:57 +08:00
|
|
|
/*
|
|
|
|
* When a protocol is opened a open protocol info entry is created.
|
|
|
|
* These are maintained in a list.
|
|
|
|
*/
|
|
|
|
struct efi_open_protocol_info_item {
|
|
|
|
/* Link to the list of open protocol info entries of a protocol */
|
|
|
|
struct list_head link;
|
|
|
|
struct efi_open_protocol_info_entry info;
|
|
|
|
};
|
|
|
|
|
2016-03-04 08:09:59 +08:00
|
|
|
/*
|
|
|
|
* 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
|
2018-01-11 15:15:57 +08:00
|
|
|
* protocol GUID to the respective protocol interface
|
|
|
|
*/
|
2016-03-04 08:09:59 +08:00
|
|
|
struct efi_handler {
|
2017-11-26 21:05:17 +08:00
|
|
|
/* Link to the list of protocols of a handle */
|
|
|
|
struct list_head link;
|
2016-03-04 08:09:59 +08:00
|
|
|
const efi_guid_t *guid;
|
2017-07-12 04:06:14 +08:00
|
|
|
void *protocol_interface;
|
2018-01-11 15:15:57 +08:00
|
|
|
/* Link to the list of open protocol info items */
|
|
|
|
struct list_head open_infos;
|
2016-03-04 08:09:59 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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;
|
2017-11-26 21:05:17 +08:00
|
|
|
/* The list of protocols */
|
|
|
|
struct list_head protocols;
|
2016-03-04 08:09:59 +08:00
|
|
|
/* The object spawner can either use this for data or as identifier */
|
|
|
|
void *handle;
|
|
|
|
};
|
|
|
|
|
2017-07-19 02:17:18 +08:00
|
|
|
/**
|
|
|
|
* struct efi_event
|
|
|
|
*
|
|
|
|
* @type: Type of event, see efi_create_event
|
|
|
|
* @notify_tpl: Task priority level of notifications
|
|
|
|
* @trigger_time: Period of the timer
|
|
|
|
* @trigger_next: Next time to trigger the timer
|
|
|
|
* @nofify_function: Function to call when the event is triggered
|
|
|
|
* @notify_context: Data to be passed to the notify function
|
|
|
|
* @trigger_type: Type of timer, see efi_set_timer
|
2017-10-04 21:03:24 +08:00
|
|
|
* @queued: The notification function is queued
|
|
|
|
* @signaled: The event occurred. The event is in the signaled state.
|
2017-07-19 02:17:18 +08:00
|
|
|
*/
|
|
|
|
struct efi_event {
|
2017-07-20 01:22:34 +08:00
|
|
|
uint32_t type;
|
2017-11-07 04:17:47 +08:00
|
|
|
efi_uintn_t notify_tpl;
|
2017-07-19 02:17:18 +08:00
|
|
|
void (EFIAPI *notify_function)(struct efi_event *event, void *context);
|
|
|
|
void *notify_context;
|
|
|
|
u64 trigger_next;
|
|
|
|
u64 trigger_time;
|
2017-07-20 01:22:34 +08:00
|
|
|
enum efi_timer_delay trigger_type;
|
2017-10-04 21:03:24 +08:00
|
|
|
bool is_queued;
|
|
|
|
bool is_signaled;
|
2017-07-19 02:17:18 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
|
2016-03-04 08:09:59 +08:00
|
|
|
/* This list contains all UEFI objects we know of */
|
|
|
|
extern struct list_head efi_obj_list;
|
|
|
|
|
2017-07-19 02:17:22 +08:00
|
|
|
/* Called by bootefi to make console interface available */
|
|
|
|
int efi_console_register(void);
|
2016-03-04 08:10:02 +08:00
|
|
|
/* Called by bootefi to make all disk storage accessible as EFI objects */
|
2018-02-10 03:55:47 +08:00
|
|
|
efi_status_t efi_disk_register(void);
|
2018-01-20 03:24:47 +08:00
|
|
|
/* Create handles and protocols for the partitions of a block device */
|
|
|
|
int efi_disk_create_partitions(efi_handle_t parent, struct blk_desc *desc,
|
|
|
|
const char *if_typename, int diskid,
|
|
|
|
const char *pdevname);
|
2016-03-16 01:38:21 +08:00
|
|
|
/* Called by bootefi to make GOP (graphical) interface available */
|
2018-03-03 22:28:55 +08:00
|
|
|
efi_status_t efi_gop_register(void);
|
2016-05-07 03:01:01 +08:00
|
|
|
/* Called by bootefi to make the network interface available */
|
2018-03-03 22:28:56 +08:00
|
|
|
efi_status_t efi_net_register(void);
|
2017-10-19 00:13:04 +08:00
|
|
|
/* Called by bootefi to make the watchdog available */
|
2018-03-03 22:28:57 +08:00
|
|
|
efi_status_t efi_watchdog_register(void);
|
2016-08-19 07:23:29 +08:00
|
|
|
/* Called by bootefi to make SMBIOS tables available */
|
2018-03-03 22:28:54 +08:00
|
|
|
efi_status_t efi_smbios_register(void);
|
2016-05-07 03:01:01 +08:00
|
|
|
|
2017-09-14 06:05:34 +08:00
|
|
|
struct efi_simple_file_system_protocol *
|
|
|
|
efi_fs_from_path(struct efi_device_path *fp);
|
|
|
|
|
2016-05-07 03:01:01 +08:00
|
|
|
/* Called by networking code to memorize the dhcp ack package */
|
|
|
|
void efi_net_set_dhcp_ack(void *pkt, int len);
|
2017-10-19 00:13:04 +08:00
|
|
|
/* Called by efi_set_watchdog_timer to reset the timer */
|
|
|
|
efi_status_t efi_set_watchdog(unsigned long timeout);
|
2016-05-07 03:01:01 +08:00
|
|
|
|
2016-03-04 08:09:59 +08:00
|
|
|
/* Called from places to check whether a timer expired */
|
|
|
|
void efi_timer_check(void);
|
|
|
|
/* PE loader implementation */
|
2016-03-04 08:09:58 +08:00
|
|
|
void *efi_load_pe(void *efi, struct efi_loaded_image *loaded_image_info);
|
2016-03-04 08:09:59 +08:00
|
|
|
/* Called once to store the pristine gd pointer */
|
|
|
|
void efi_save_gd(void);
|
2017-07-27 20:04:18 +08:00
|
|
|
/* Special case handler for error/abort that just tries to dtrt to get
|
|
|
|
* back to u-boot world */
|
2016-03-04 08:09:59 +08:00
|
|
|
void efi_restore_gd(void);
|
2016-03-04 08:10:01 +08:00
|
|
|
/* Call this to relocate the runtime section to an address space */
|
|
|
|
void efi_runtime_relocate(ulong offset, struct efi_mem_desc *map);
|
2016-03-04 08:10:14 +08:00
|
|
|
/* Call this to set the current device name */
|
2016-04-11 22:16:19 +08:00
|
|
|
void efi_set_bootdev(const char *dev, const char *devnr, const char *path);
|
2017-11-26 21:05:23 +08:00
|
|
|
/* Add a new object to the object list. */
|
|
|
|
void efi_add_handle(struct efi_object *obj);
|
2017-10-27 01:25:49 +08:00
|
|
|
/* Create handle */
|
2018-01-11 15:16:09 +08:00
|
|
|
efi_status_t efi_create_handle(efi_handle_t *handle);
|
2017-12-05 01:03:02 +08:00
|
|
|
/* Delete handle */
|
|
|
|
void efi_delete_handle(struct efi_object *obj);
|
2017-11-07 04:17:50 +08:00
|
|
|
/* Call this to validate a handle and find the EFI object for it */
|
2018-01-11 15:16:09 +08:00
|
|
|
struct efi_object *efi_search_obj(const efi_handle_t handle);
|
2017-10-27 01:25:53 +08:00
|
|
|
/* Find a protocol on a handle */
|
2018-01-11 15:16:09 +08:00
|
|
|
efi_status_t efi_search_protocol(const efi_handle_t handle,
|
2017-10-27 01:25:53 +08:00
|
|
|
const efi_guid_t *protocol_guid,
|
|
|
|
struct efi_handler **handler);
|
|
|
|
/* Install new protocol on a handle */
|
2018-01-11 15:16:09 +08:00
|
|
|
efi_status_t efi_add_protocol(const efi_handle_t handle,
|
|
|
|
const efi_guid_t *protocol,
|
2017-10-27 01:25:53 +08:00
|
|
|
void *protocol_interface);
|
|
|
|
/* Delete protocol from a handle */
|
2018-01-11 15:16:09 +08:00
|
|
|
efi_status_t efi_remove_protocol(const efi_handle_t handle,
|
|
|
|
const efi_guid_t *protocol,
|
2017-10-27 01:25:53 +08:00
|
|
|
void *protocol_interface);
|
|
|
|
/* Delete all protocols from a handle */
|
2018-01-11 15:16:09 +08:00
|
|
|
efi_status_t efi_remove_all_protocols(const efi_handle_t handle);
|
2017-07-19 02:17:20 +08:00
|
|
|
/* Call this to create an event */
|
2017-11-07 04:17:47 +08:00
|
|
|
efi_status_t efi_create_event(uint32_t type, efi_uintn_t notify_tpl,
|
2017-07-19 02:17:20 +08:00
|
|
|
void (EFIAPI *notify_function) (
|
|
|
|
struct efi_event *event,
|
|
|
|
void *context),
|
|
|
|
void *notify_context, struct efi_event **event);
|
2017-07-19 02:17:21 +08:00
|
|
|
/* Call this to set a timer */
|
2017-07-20 01:22:34 +08:00
|
|
|
efi_status_t efi_set_timer(struct efi_event *event, enum efi_timer_delay type,
|
2017-07-19 02:17:21 +08:00
|
|
|
uint64_t trigger_time);
|
2017-07-19 02:17:22 +08:00
|
|
|
/* Call this to signal an event */
|
2018-01-20 03:24:51 +08:00
|
|
|
void efi_signal_event(struct efi_event *event, bool check_tpl);
|
2016-03-04 08:10:01 +08:00
|
|
|
|
2017-09-14 06:05:34 +08:00
|
|
|
/* open file system: */
|
|
|
|
struct efi_simple_file_system_protocol *efi_simple_file_system(
|
|
|
|
struct blk_desc *desc, int part, struct efi_device_path *dp);
|
|
|
|
|
|
|
|
/* open file from device-path: */
|
|
|
|
struct efi_file_handle *efi_file_from_path(struct efi_device_path *fp);
|
|
|
|
|
|
|
|
|
2016-03-04 08:10:04 +08:00
|
|
|
/* Generic EFI memory allocator, call this to get memory */
|
|
|
|
void *efi_alloc(uint64_t len, int memory_type);
|
|
|
|
/* More specific EFI memory allocator, called by EFI payloads */
|
2017-11-07 04:17:48 +08:00
|
|
|
efi_status_t efi_allocate_pages(int type, int memory_type, efi_uintn_t pages,
|
2016-03-04 08:10:04 +08:00
|
|
|
uint64_t *memory);
|
2016-10-02 05:32:27 +08:00
|
|
|
/* EFI memory free function. */
|
2017-11-07 04:17:48 +08:00
|
|
|
efi_status_t efi_free_pages(uint64_t memory, efi_uintn_t pages);
|
2016-10-10 04:17:18 +08:00
|
|
|
/* EFI memory allocator for small allocations */
|
2017-11-07 04:17:48 +08:00
|
|
|
efi_status_t efi_allocate_pool(int pool_type, efi_uintn_t size,
|
2016-10-10 04:17:18 +08:00
|
|
|
void **buffer);
|
2016-10-10 04:17:26 +08:00
|
|
|
/* EFI pool memory free function. */
|
|
|
|
efi_status_t efi_free_pool(void *buffer);
|
2016-03-04 08:10:04 +08:00
|
|
|
/* Returns the EFI memory map */
|
2017-11-07 04:17:48 +08:00
|
|
|
efi_status_t efi_get_memory_map(efi_uintn_t *memory_map_size,
|
2016-03-04 08:10:04 +08:00
|
|
|
struct efi_mem_desc *memory_map,
|
2017-11-07 04:17:48 +08:00
|
|
|
efi_uintn_t *map_key,
|
|
|
|
efi_uintn_t *descriptor_size,
|
2016-03-04 08:10:04 +08:00
|
|
|
uint32_t *descriptor_version);
|
|
|
|
/* Adds a range into the EFI memory map */
|
|
|
|
uint64_t efi_add_memory_map(uint64_t start, uint64_t pages, int memory_type,
|
|
|
|
bool overlap_only_ram);
|
2018-01-22 02:29:30 +08:00
|
|
|
/* Called by board init to initialize the EFI drivers */
|
2018-02-01 19:53:32 +08:00
|
|
|
efi_status_t efi_driver_init(void);
|
2016-03-04 08:10:04 +08:00
|
|
|
/* Called by board init to initialize the EFI memory map */
|
|
|
|
int efi_memory_init(void);
|
2016-08-19 07:23:24 +08:00
|
|
|
/* Adds new or overrides configuration table entry to the system table */
|
|
|
|
efi_status_t efi_install_configuration_table(const efi_guid_t *guid, void *table);
|
2017-12-05 01:03:01 +08:00
|
|
|
/* Sets up a loaded image */
|
|
|
|
efi_status_t efi_setup_loaded_image(
|
|
|
|
struct efi_loaded_image *info, struct efi_object *obj,
|
|
|
|
struct efi_device_path *device_path,
|
|
|
|
struct efi_device_path *file_path);
|
2017-09-14 06:05:38 +08:00
|
|
|
efi_status_t efi_load_image_from_path(struct efi_device_path *file_path,
|
|
|
|
void **buffer);
|
2016-03-04 08:10:04 +08:00
|
|
|
|
2016-05-12 00:25:48 +08:00
|
|
|
#ifdef CONFIG_EFI_LOADER_BOUNCE_BUFFER
|
|
|
|
extern void *efi_bounce_buffer;
|
|
|
|
#define EFI_LOADER_BOUNCE_BUFFER_SIZE (64 * 1024 * 1024)
|
|
|
|
#endif
|
|
|
|
|
2017-09-14 06:05:28 +08:00
|
|
|
|
|
|
|
struct efi_device_path *efi_dp_next(const struct efi_device_path *dp);
|
2017-10-27 01:25:48 +08:00
|
|
|
int efi_dp_match(const struct efi_device_path *a,
|
|
|
|
const struct efi_device_path *b);
|
2017-09-14 06:05:28 +08:00
|
|
|
struct efi_object *efi_dp_find_obj(struct efi_device_path *dp,
|
|
|
|
struct efi_device_path **rem);
|
|
|
|
unsigned efi_dp_size(const struct efi_device_path *dp);
|
|
|
|
struct efi_device_path *efi_dp_dup(const struct efi_device_path *dp);
|
|
|
|
struct efi_device_path *efi_dp_append(const struct efi_device_path *dp1,
|
|
|
|
const struct efi_device_path *dp2);
|
|
|
|
struct efi_device_path *efi_dp_append_node(const struct efi_device_path *dp,
|
|
|
|
const struct efi_device_path *node);
|
|
|
|
|
|
|
|
|
|
|
|
struct efi_device_path *efi_dp_from_dev(struct udevice *dev);
|
|
|
|
struct efi_device_path *efi_dp_from_part(struct blk_desc *desc, int part);
|
2018-01-20 03:24:46 +08:00
|
|
|
/* Create a device node for a block device partition. */
|
|
|
|
struct efi_device_path *efi_dp_part_node(struct blk_desc *desc, int part);
|
2017-09-14 06:05:28 +08:00
|
|
|
struct efi_device_path *efi_dp_from_file(struct blk_desc *desc, int part,
|
|
|
|
const char *path);
|
|
|
|
struct efi_device_path *efi_dp_from_eth(void);
|
2017-10-10 20:23:06 +08:00
|
|
|
struct efi_device_path *efi_dp_from_mem(uint32_t mem_type,
|
|
|
|
uint64_t start_address,
|
|
|
|
uint64_t end_address);
|
2018-01-20 03:24:49 +08:00
|
|
|
/* Determine the last device path node that is not the end node. */
|
|
|
|
const struct efi_device_path *efi_dp_last_node(
|
|
|
|
const struct efi_device_path *dp);
|
2018-01-20 03:24:37 +08:00
|
|
|
efi_status_t efi_dp_split_file_path(struct efi_device_path *full_path,
|
|
|
|
struct efi_device_path **device_path,
|
|
|
|
struct efi_device_path **file_path);
|
2017-09-14 06:05:28 +08:00
|
|
|
|
|
|
|
#define EFI_DP_TYPE(_dp, _type, _subtype) \
|
|
|
|
(((_dp)->type == DEVICE_PATH_TYPE_##_type) && \
|
|
|
|
((_dp)->sub_type == DEVICE_PATH_SUB_TYPE_##_subtype))
|
|
|
|
|
2016-03-04 08:10:14 +08:00
|
|
|
/* Convert strings from normal C strings to uEFI strings */
|
2016-05-15 04:03:05 +08:00
|
|
|
static inline void ascii2unicode(u16 *unicode, const char *ascii)
|
2016-03-04 08:10:14 +08:00
|
|
|
{
|
|
|
|
while (*ascii)
|
|
|
|
*(unicode++) = *(ascii++);
|
|
|
|
}
|
|
|
|
|
2017-07-24 19:59:11 +08:00
|
|
|
static inline int guidcmp(const efi_guid_t *g1, const efi_guid_t *g2)
|
|
|
|
{
|
|
|
|
return memcmp(g1, g2, sizeof(efi_guid_t));
|
|
|
|
}
|
|
|
|
|
2016-03-04 08:10:01 +08:00
|
|
|
/*
|
|
|
|
* 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
|
|
|
|
*/
|
2016-10-14 19:45:30 +08:00
|
|
|
#define __efi_runtime_data __attribute__ ((section ("efi_runtime_data")))
|
|
|
|
#define __efi_runtime __attribute__ ((section ("efi_runtime_text")))
|
2016-03-04 08:09:59 +08:00
|
|
|
|
2016-08-17 03:08:45 +08:00
|
|
|
/* Call this with mmio_ptr as the _pointer_ to a pointer to an MMIO region
|
|
|
|
* to make it available at runtime */
|
2018-03-03 22:28:59 +08:00
|
|
|
efi_status_t efi_add_runtime_mmio(void *mmio_ptr, u64 len);
|
2016-08-17 03:08:45 +08:00
|
|
|
|
|
|
|
/* Boards may provide the functions below to implement RTS functionality */
|
|
|
|
|
2016-10-14 19:45:30 +08:00
|
|
|
void __efi_runtime EFIAPI efi_reset_system(
|
2016-08-17 03:08:45 +08:00
|
|
|
enum efi_reset_type reset_type,
|
|
|
|
efi_status_t reset_status,
|
|
|
|
unsigned long data_size, void *reset_data);
|
2018-03-03 22:28:59 +08:00
|
|
|
|
|
|
|
/* Architecture specific initialization of the EFI subsystem */
|
|
|
|
efi_status_t efi_reset_system_init(void);
|
2016-08-17 03:08:45 +08:00
|
|
|
|
2016-10-14 19:45:30 +08:00
|
|
|
efi_status_t __efi_runtime EFIAPI efi_get_time(
|
2016-08-17 03:08:45 +08:00
|
|
|
struct efi_time *time,
|
|
|
|
struct efi_time_cap *capabilities);
|
|
|
|
void efi_get_time_init(void);
|
|
|
|
|
2017-09-15 16:06:11 +08:00
|
|
|
#ifdef CONFIG_CMD_BOOTEFI_SELFTEST
|
|
|
|
/*
|
|
|
|
* Entry point for the tests of the EFI API.
|
|
|
|
* It is called by 'bootefi selftest'
|
|
|
|
*/
|
|
|
|
efi_status_t EFIAPI efi_selftest(efi_handle_t image_handle,
|
|
|
|
struct efi_system_table *systab);
|
|
|
|
#endif
|
|
|
|
|
efi_loader: efi variable support
Add EFI variable support, mapping to u-boot environment variables.
Variables are pretty important for setting up boot order, among other
things. If the board supports saveenv, then it will be called in
ExitBootServices() to persist variables set by the efi payload. (For
example, fallback.efi configuring BootOrder and BootXXXX load-option
variables.)
Variables are *not* currently exposed at runtime, post ExitBootServices.
On boards without a dedicated device for storage, which the loaded OS
is not trying to also use, this is rather tricky. One idea, at least
for boards that can persist RAM across reboot, is to keep a "journal"
of modified variables in RAM, and then turn halt into a reboot into
u-boot, plus store variables, plus halt. Whatever the solution, it
likely involves some per-board support.
Mapping between EFI variables and u-boot variables:
efi_$guid_$varname = {attributes}(type)value
For example:
efi_8be4df61-93ca-11d2-aa0d-00e098032b8c_OsIndicationsSupported=
"{ro,boot,run}(blob)0000000000000000"
efi_8be4df61-93ca-11d2-aa0d-00e098032b8c_BootOrder=
"(blob)00010000"
The attributes are a comma separated list of these possible
attributes:
+ ro - read-only
+ boot - boot-services access
+ run - runtime access
NOTE: with current implementation, no variables are available after
ExitBootServices, and all are persisted (if possible).
If not specified, the attributes default to "{boot}".
The required type is one of:
+ utf8 - raw utf8 string
+ blob - arbitrary length hex string
Signed-off-by: Rob Clark <robdclark@gmail.com>
Signed-off-by: Alexander Graf <agraf@suse.de>
2017-09-14 06:05:37 +08:00
|
|
|
efi_status_t EFIAPI efi_get_variable(s16 *variable_name,
|
|
|
|
efi_guid_t *vendor, u32 *attributes,
|
|
|
|
unsigned long *data_size, void *data);
|
|
|
|
efi_status_t EFIAPI efi_get_next_variable(
|
|
|
|
unsigned long *variable_name_size,
|
|
|
|
s16 *variable_name, efi_guid_t *vendor);
|
|
|
|
efi_status_t EFIAPI efi_set_variable(s16 *variable_name,
|
|
|
|
efi_guid_t *vendor, u32 attributes,
|
|
|
|
unsigned long data_size, void *data);
|
|
|
|
|
2017-09-14 06:05:38 +08:00
|
|
|
void *efi_bootmgr_load(struct efi_device_path **device_path,
|
|
|
|
struct efi_device_path **file_path);
|
|
|
|
|
2016-03-04 08:09:59 +08:00
|
|
|
#else /* defined(EFI_LOADER) && !defined(CONFIG_SPL_BUILD) */
|
|
|
|
|
2016-03-04 08:10:01 +08:00
|
|
|
/* Without CONFIG_EFI_LOADER we don't have a runtime section, stub it out */
|
2016-10-14 19:45:30 +08:00
|
|
|
#define __efi_runtime_data
|
|
|
|
#define __efi_runtime
|
2018-03-03 22:28:59 +08:00
|
|
|
static inline efi_status_t efi_add_runtime_mmio(void *mmio_ptr, u64 len)
|
|
|
|
{
|
|
|
|
return EFI_SUCCESS;
|
|
|
|
}
|
2016-03-04 08:10:01 +08:00
|
|
|
|
2016-03-04 08:09:59 +08:00
|
|
|
/* No loader configured, stub out EFI_ENTRY */
|
|
|
|
static inline void efi_restore_gd(void) { }
|
2016-04-11 22:16:19 +08:00
|
|
|
static inline void efi_set_bootdev(const char *dev, const char *devnr,
|
|
|
|
const char *path) { }
|
2016-05-07 03:01:01 +08:00
|
|
|
static inline void efi_net_set_dhcp_ack(void *pkt, int len) { }
|
2016-03-04 08:09:59 +08:00
|
|
|
|
2017-10-19 00:13:07 +08:00
|
|
|
#endif /* CONFIG_EFI_LOADER && !CONFIG_SPL_BUILD */
|
|
|
|
|
|
|
|
#endif /* _EFI_LOADER_H */
|