Tom Rini | 70df9d6 | 2018-05-07 17:02:21 -0400 | [diff] [blame] | 1 | /* SPDX-License-Identifier: GPL-2.0+ */ |
Alexander Graf | 4e0c1c1 | 2016-03-04 01:09:58 +0100 | [diff] [blame] | 2 | /* |
| 3 | * EFI application loader |
| 4 | * |
| 5 | * Copyright (c) 2016 Alexander Graf |
Alexander Graf | 4e0c1c1 | 2016-03-04 01:09:58 +0100 | [diff] [blame] | 6 | */ |
| 7 | |
Heinrich Schuchardt | c2fd477 | 2017-10-18 18:13:07 +0200 | [diff] [blame] | 8 | #ifndef _EFI_LOADER_H |
| 9 | #define _EFI_LOADER_H 1 |
| 10 | |
Alexander Graf | c15d921 | 2016-03-04 01:09:59 +0100 | [diff] [blame] | 11 | #include <common.h> |
Simon Glass | 655306c | 2020-05-10 11:39:58 -0600 | [diff] [blame] | 12 | #include <blk.h> |
Simon Glass | 0f2af88 | 2020-05-10 11:40:05 -0600 | [diff] [blame] | 13 | #include <log.h> |
Alexander Graf | 4e0c1c1 | 2016-03-04 01:09:58 +0100 | [diff] [blame] | 14 | #include <part_efi.h> |
| 15 | #include <efi_api.h> |
AKASHI Takahiro | 2c0f9f7 | 2020-04-21 09:38:38 +0900 | [diff] [blame] | 16 | #include <image.h> |
AKASHI Takahiro | 0e104e3 | 2020-04-14 11:51:44 +0900 | [diff] [blame] | 17 | #include <pe.h> |
Alexander Graf | c15d921 | 2016-03-04 01:09:59 +0100 | [diff] [blame] | 18 | |
Simon Glass | 655306c | 2020-05-10 11:39:58 -0600 | [diff] [blame] | 19 | struct blk_desc; |
| 20 | |
Simon Glass | 16fc74a | 2019-09-25 08:11:32 -0600 | [diff] [blame] | 21 | static inline int guidcmp(const void *g1, const void *g2) |
| 22 | { |
| 23 | return memcmp(g1, g2, sizeof(efi_guid_t)); |
| 24 | } |
| 25 | |
Sughosh Ganu | 196f66d | 2019-12-29 00:01:04 +0530 | [diff] [blame] | 26 | static inline void *guidcpy(void *dst, const void *src) |
| 27 | { |
| 28 | return memcpy(dst, src, sizeof(efi_guid_t)); |
| 29 | } |
| 30 | |
Alexander Graf | c15d921 | 2016-03-04 01:09:59 +0100 | [diff] [blame] | 31 | /* No need for efi loader support in SPL */ |
Stephen Warren | d0de806 | 2018-08-30 15:43:43 -0600 | [diff] [blame] | 32 | #if CONFIG_IS_ENABLED(EFI_LOADER) |
Alexander Graf | c15d921 | 2016-03-04 01:09:59 +0100 | [diff] [blame] | 33 | |
Alexander Graf | 4e0c1c1 | 2016-03-04 01:09:58 +0100 | [diff] [blame] | 34 | #include <linux/list.h> |
AKASHI Takahiro | 1faaca4 | 2020-04-14 11:51:39 +0900 | [diff] [blame] | 35 | #include <linux/oid_registry.h> |
Alexander Graf | 4e0c1c1 | 2016-03-04 01:09:58 +0100 | [diff] [blame] | 36 | |
Heinrich Schuchardt | 2f528c2 | 2018-06-28 12:45:32 +0200 | [diff] [blame] | 37 | /* Maximum number of configuration tables */ |
| 38 | #define EFI_MAX_CONFIGURATION_TABLES 16 |
| 39 | |
Heinrich Schuchardt | 79d7202 | 2018-09-20 21:58:23 +0200 | [diff] [blame] | 40 | /* GUID used by the root node */ |
| 41 | #define U_BOOT_GUID \ |
| 42 | EFI_GUID(0xe61d73b9, 0xa384, 0x4acc, \ |
| 43 | 0xae, 0xab, 0x82, 0xe8, 0x28, 0xf3, 0x62, 0x8b) |
AKASHI Takahiro | 659a626 | 2019-09-12 13:52:35 +0900 | [diff] [blame] | 44 | /* GUID used as host device on sandbox */ |
| 45 | #define U_BOOT_HOST_DEV_GUID \ |
| 46 | EFI_GUID(0xbbe4e671, 0x5773, 0x4ea1, \ |
| 47 | 0x9a, 0xab, 0x3a, 0x7d, 0xbf, 0x40, 0xc4, 0x82) |
Heinrich Schuchardt | c770aaa | 2020-05-20 22:39:35 +0200 | [diff] [blame] | 48 | /* GUID used as root for virtio devices */ |
| 49 | #define U_BOOT_VIRTIO_DEV_GUID \ |
| 50 | EFI_GUID(0x63293792, 0xadf5, 0x9325, \ |
| 51 | 0xb9, 0x9f, 0x4e, 0x0e, 0x45, 0x5c, 0x1b, 0x1e) |
Heinrich Schuchardt | 79d7202 | 2018-09-20 21:58:23 +0200 | [diff] [blame] | 52 | |
Heinrich Schuchardt | 6fbb8ac | 2019-11-28 06:46:09 +0100 | [diff] [blame] | 53 | /* Use internal device tree when starting UEFI application */ |
Heinrich Schuchardt | 6246741 | 2019-12-08 01:07:01 +0100 | [diff] [blame] | 54 | #define EFI_FDT_USE_INTERNAL NULL |
Heinrich Schuchardt | 6fbb8ac | 2019-11-28 06:46:09 +0100 | [diff] [blame] | 55 | |
AKASHI Takahiro | 0b27575 | 2019-04-16 13:24:20 +0900 | [diff] [blame] | 56 | /* Root node */ |
| 57 | extern efi_handle_t efi_root; |
| 58 | |
Heinrich Schuchardt | a993173 | 2020-03-19 15:16:31 +0100 | [diff] [blame] | 59 | /* EFI system partition */ |
| 60 | extern struct efi_system_partition { |
| 61 | enum if_type if_type; |
| 62 | int devnum; |
| 63 | u8 part; |
| 64 | } efi_system_partition; |
| 65 | |
Rob Clark | 86789d5 | 2017-07-27 08:04:18 -0400 | [diff] [blame] | 66 | int __efi_entry_check(void); |
| 67 | int __efi_exit_check(void); |
Heinrich Schuchardt | 4d66489 | 2017-08-18 17:45:16 +0200 | [diff] [blame] | 68 | const char *__efi_nesting(void); |
Rob Clark | e7896c3 | 2017-07-27 08:04:19 -0400 | [diff] [blame] | 69 | const char *__efi_nesting_inc(void); |
| 70 | const char *__efi_nesting_dec(void); |
Rob Clark | 86789d5 | 2017-07-27 08:04:18 -0400 | [diff] [blame] | 71 | |
Rob Clark | 63ea77a | 2017-07-27 08:04:17 -0400 | [diff] [blame] | 72 | /* |
| 73 | * Enter the u-boot world from UEFI: |
| 74 | */ |
Alexander Graf | c15d921 | 2016-03-04 01:09:59 +0100 | [diff] [blame] | 75 | #define EFI_ENTRY(format, ...) do { \ |
Rob Clark | 86789d5 | 2017-07-27 08:04:18 -0400 | [diff] [blame] | 76 | assert(__efi_entry_check()); \ |
Rob Clark | e7896c3 | 2017-07-27 08:04:19 -0400 | [diff] [blame] | 77 | debug("%sEFI: Entry %s(" format ")\n", __efi_nesting_inc(), \ |
| 78 | __func__, ##__VA_ARGS__); \ |
Alexander Graf | c15d921 | 2016-03-04 01:09:59 +0100 | [diff] [blame] | 79 | } while(0) |
Alexander Graf | c15d921 | 2016-03-04 01:09:59 +0100 | [diff] [blame] | 80 | |
Rob Clark | 63ea77a | 2017-07-27 08:04:17 -0400 | [diff] [blame] | 81 | /* |
| 82 | * Exit the u-boot world back to UEFI: |
| 83 | */ |
Rob Clark | 84a19a0 | 2017-07-24 10:31:52 -0400 | [diff] [blame] | 84 | #define EFI_EXIT(ret) ({ \ |
xypron.glpk@gmx.de | 8f9dd92 | 2017-08-17 18:57:36 +0200 | [diff] [blame] | 85 | typeof(ret) _r = ret; \ |
Rob Clark | e7896c3 | 2017-07-27 08:04:19 -0400 | [diff] [blame] | 86 | debug("%sEFI: Exit: %s: %u\n", __efi_nesting_dec(), \ |
xypron.glpk@gmx.de | 8f9dd92 | 2017-08-17 18:57:36 +0200 | [diff] [blame] | 87 | __func__, (u32)((uintptr_t) _r & ~EFI_ERROR_MASK)); \ |
Rob Clark | 86789d5 | 2017-07-27 08:04:18 -0400 | [diff] [blame] | 88 | assert(__efi_exit_check()); \ |
| 89 | _r; \ |
Rob Clark | 84a19a0 | 2017-07-24 10:31:52 -0400 | [diff] [blame] | 90 | }) |
Alexander Graf | c15d921 | 2016-03-04 01:09:59 +0100 | [diff] [blame] | 91 | |
Rob Clark | 63ea77a | 2017-07-27 08:04:17 -0400 | [diff] [blame] | 92 | /* |
Heinrich Schuchardt | 91e5b8a | 2017-09-15 10:06:10 +0200 | [diff] [blame] | 93 | * Call non-void UEFI function from u-boot and retrieve return value: |
| 94 | */ |
| 95 | #define EFI_CALL(exp) ({ \ |
| 96 | debug("%sEFI: Call: %s\n", __efi_nesting_inc(), #exp); \ |
| 97 | assert(__efi_exit_check()); \ |
| 98 | typeof(exp) _r = exp; \ |
| 99 | assert(__efi_entry_check()); \ |
| 100 | debug("%sEFI: %lu returned by %s\n", __efi_nesting_dec(), \ |
| 101 | (unsigned long)((uintptr_t)_r & ~EFI_ERROR_MASK), #exp); \ |
| 102 | _r; \ |
| 103 | }) |
| 104 | |
| 105 | /* |
| 106 | * Call void UEFI function from u-boot: |
Rob Clark | 63ea77a | 2017-07-27 08:04:17 -0400 | [diff] [blame] | 107 | */ |
Heinrich Schuchardt | 91e5b8a | 2017-09-15 10:06:10 +0200 | [diff] [blame] | 108 | #define EFI_CALL_VOID(exp) do { \ |
Rob Clark | e7896c3 | 2017-07-27 08:04:19 -0400 | [diff] [blame] | 109 | debug("%sEFI: Call: %s\n", __efi_nesting_inc(), #exp); \ |
Rob Clark | 86789d5 | 2017-07-27 08:04:18 -0400 | [diff] [blame] | 110 | assert(__efi_exit_check()); \ |
Rob Clark | 63ea77a | 2017-07-27 08:04:17 -0400 | [diff] [blame] | 111 | exp; \ |
Rob Clark | 86789d5 | 2017-07-27 08:04:18 -0400 | [diff] [blame] | 112 | assert(__efi_entry_check()); \ |
Rob Clark | e7896c3 | 2017-07-27 08:04:19 -0400 | [diff] [blame] | 113 | debug("%sEFI: Return From: %s\n", __efi_nesting_dec(), #exp); \ |
Rob Clark | 63ea77a | 2017-07-27 08:04:17 -0400 | [diff] [blame] | 114 | } while(0) |
| 115 | |
Heinrich Schuchardt | 4d66489 | 2017-08-18 17:45:16 +0200 | [diff] [blame] | 116 | /* |
Heinrich Schuchardt | 3d2abc3 | 2018-01-11 08:16:01 +0100 | [diff] [blame] | 117 | * Write an indented message with EFI prefix |
Heinrich Schuchardt | 4d66489 | 2017-08-18 17:45:16 +0200 | [diff] [blame] | 118 | */ |
Heinrich Schuchardt | 3d2abc3 | 2018-01-11 08:16:01 +0100 | [diff] [blame] | 119 | #define EFI_PRINT(format, ...) ({ \ |
| 120 | debug("%sEFI: " format, __efi_nesting(), \ |
| 121 | ##__VA_ARGS__); \ |
Heinrich Schuchardt | 4d66489 | 2017-08-18 17:45:16 +0200 | [diff] [blame] | 122 | }) |
| 123 | |
Alexander Graf | 59254d6 | 2018-04-23 07:59:47 +0200 | [diff] [blame] | 124 | #ifdef CONFIG_SYS_CACHELINE_SIZE |
| 125 | #define EFI_CACHELINE_SIZE CONFIG_SYS_CACHELINE_SIZE |
| 126 | #else |
| 127 | /* Just use the greatest cache flush alignment requirement I'm aware of */ |
| 128 | #define EFI_CACHELINE_SIZE 128 |
| 129 | #endif |
| 130 | |
Heinrich Schuchardt | 0f233c4 | 2018-07-02 12:53:55 +0200 | [diff] [blame] | 131 | /* Key identifying current memory map */ |
| 132 | extern efi_uintn_t efi_memory_map_key; |
| 133 | |
Alexander Graf | 0bd425a | 2016-03-04 01:10:01 +0100 | [diff] [blame] | 134 | extern struct efi_runtime_services efi_runtime_services; |
Alexander Graf | c15d921 | 2016-03-04 01:09:59 +0100 | [diff] [blame] | 135 | extern struct efi_system_table systab; |
| 136 | |
Heinrich Schuchardt | 580c13b | 2017-10-26 19:25:59 +0200 | [diff] [blame] | 137 | extern struct efi_simple_text_output_protocol efi_con_out; |
Heinrich Schuchardt | 3dabffd | 2018-09-08 10:20:10 +0200 | [diff] [blame] | 138 | extern struct efi_simple_text_input_protocol efi_con_in; |
Heinrich Schuchardt | 580c13b | 2017-10-26 19:25:59 +0200 | [diff] [blame] | 139 | extern struct efi_console_control_protocol efi_console_control; |
xypron.glpk@gmx.de | 3c042b2 | 2017-07-11 22:06:25 +0200 | [diff] [blame] | 140 | extern const struct efi_device_path_to_text_protocol efi_device_path_to_text; |
Leif Lindholm | b6e6fdc | 2018-03-09 17:43:21 +0100 | [diff] [blame] | 141 | /* implementation of the EFI_DEVICE_PATH_UTILITIES_PROTOCOL */ |
| 142 | extern const struct efi_device_path_utilities_protocol |
| 143 | efi_device_path_utilities; |
Heinrich Schuchardt | 18ed8cf | 2019-05-16 18:19:00 +0200 | [diff] [blame] | 144 | /* deprecated version of the EFI_UNICODE_COLLATION_PROTOCOL */ |
| 145 | extern const struct efi_unicode_collation_protocol |
| 146 | efi_unicode_collation_protocol; |
| 147 | /* current version of the EFI_UNICODE_COLLATION_PROTOCOL */ |
Heinrich Schuchardt | e59072a | 2018-09-04 19:34:58 +0200 | [diff] [blame] | 148 | extern const struct efi_unicode_collation_protocol |
Heinrich Schuchardt | b325884 | 2019-05-16 07:52:58 +0200 | [diff] [blame] | 149 | efi_unicode_collation_protocol2; |
AKASHI Takahiro | ca8aa71 | 2019-01-21 12:13:00 +0900 | [diff] [blame] | 150 | extern const struct efi_hii_config_routing_protocol efi_hii_config_routing; |
| 151 | extern const struct efi_hii_config_access_protocol efi_hii_config_access; |
Leif Lindholm | 5aab1b8 | 2019-01-21 12:12:57 +0900 | [diff] [blame] | 152 | extern const struct efi_hii_database_protocol efi_hii_database; |
| 153 | extern const struct efi_hii_string_protocol efi_hii_string; |
Sughosh Ganu | 693a4f4 | 2019-12-29 00:01:06 +0530 | [diff] [blame] | 154 | extern const struct efi_rng_protocol efi_rng_protocol; |
Alexander Graf | 4aacacc | 2016-03-04 01:10:00 +0100 | [diff] [blame] | 155 | |
Rob Clark | 85dd721 | 2017-09-13 18:05:30 -0400 | [diff] [blame] | 156 | uint16_t *efi_dp_str(struct efi_device_path *dp); |
| 157 | |
Heinrich Schuchardt | 79d7202 | 2018-09-20 21:58:23 +0200 | [diff] [blame] | 158 | /* GUID of the U-Boot root node */ |
| 159 | extern const efi_guid_t efi_u_boot_guid; |
AKASHI Takahiro | 659a626 | 2019-09-12 13:52:35 +0900 | [diff] [blame] | 160 | #ifdef CONFIG_SANDBOX |
| 161 | /* GUID of U-Boot host device on sandbox */ |
| 162 | extern const efi_guid_t efi_guid_host_dev; |
| 163 | #endif |
Heinrich Schuchardt | 405afb5 | 2018-01-19 20:24:45 +0100 | [diff] [blame] | 164 | /* GUID of the EFI_BLOCK_IO_PROTOCOL */ |
| 165 | extern const efi_guid_t efi_block_io_guid; |
Rob Clark | c84c110 | 2017-09-13 18:05:38 -0400 | [diff] [blame] | 166 | extern const efi_guid_t efi_global_variable_guid; |
Alexander Graf | 4aacacc | 2016-03-04 01:10:00 +0100 | [diff] [blame] | 167 | extern const efi_guid_t efi_guid_console_control; |
Alexander Graf | 4e0c1c1 | 2016-03-04 01:09:58 +0100 | [diff] [blame] | 168 | extern const efi_guid_t efi_guid_device_path; |
Heinrich Schuchardt | 760255f | 2018-01-11 08:16:02 +0100 | [diff] [blame] | 169 | /* GUID of the EFI_DRIVER_BINDING_PROTOCOL */ |
| 170 | extern const efi_guid_t efi_guid_driver_binding_protocol; |
Heinrich Schuchardt | 672d99e | 2018-02-18 15:17:51 +0100 | [diff] [blame] | 171 | /* event group ExitBootServices() invoked */ |
| 172 | extern const efi_guid_t efi_guid_event_group_exit_boot_services; |
| 173 | /* event group SetVirtualAddressMap() invoked */ |
| 174 | extern const efi_guid_t efi_guid_event_group_virtual_address_change; |
| 175 | /* event group memory map changed */ |
| 176 | extern const efi_guid_t efi_guid_event_group_memory_map_change; |
| 177 | /* event group boot manager about to boot */ |
| 178 | extern const efi_guid_t efi_guid_event_group_ready_to_boot; |
| 179 | /* event group ResetSystem() invoked (before ExitBootServices) */ |
| 180 | extern const efi_guid_t efi_guid_event_group_reset_system; |
Heinrich Schuchardt | 44ab21b | 2018-03-03 15:29:03 +0100 | [diff] [blame] | 181 | /* GUID of the device tree table */ |
| 182 | extern const efi_guid_t efi_guid_fdt; |
Alexander Graf | 4e0c1c1 | 2016-03-04 01:09:58 +0100 | [diff] [blame] | 183 | extern const efi_guid_t efi_guid_loaded_image; |
AKASHI Takahiro | bbe13da | 2019-03-27 13:40:32 +0900 | [diff] [blame] | 184 | extern const efi_guid_t efi_guid_loaded_image_device_path; |
xypron.glpk@gmx.de | 3c042b2 | 2017-07-11 22:06:25 +0200 | [diff] [blame] | 185 | extern const efi_guid_t efi_guid_device_path_to_text_protocol; |
Rob Clark | 5314203 | 2017-09-13 18:05:34 -0400 | [diff] [blame] | 186 | extern const efi_guid_t efi_simple_file_system_protocol_guid; |
| 187 | extern const efi_guid_t efi_file_info_guid; |
Heinrich Schuchardt | 37fb4b9 | 2018-04-04 15:42:11 +0200 | [diff] [blame] | 188 | /* GUID for file system information */ |
| 189 | extern const efi_guid_t efi_file_system_info_guid; |
Leif Lindholm | b6e6fdc | 2018-03-09 17:43:21 +0100 | [diff] [blame] | 190 | extern const efi_guid_t efi_guid_device_path_utilities_protocol; |
Heinrich Schuchardt | 18ed8cf | 2019-05-16 18:19:00 +0200 | [diff] [blame] | 191 | /* GUID of the deprecated Unicode collation protocol */ |
| 192 | extern const efi_guid_t efi_guid_unicode_collation_protocol; |
Heinrich Schuchardt | e59072a | 2018-09-04 19:34:58 +0200 | [diff] [blame] | 193 | /* GUID of the Unicode collation protocol */ |
Heinrich Schuchardt | b325884 | 2019-05-16 07:52:58 +0200 | [diff] [blame] | 194 | extern const efi_guid_t efi_guid_unicode_collation_protocol2; |
AKASHI Takahiro | ca8aa71 | 2019-01-21 12:13:00 +0900 | [diff] [blame] | 195 | extern const efi_guid_t efi_guid_hii_config_routing_protocol; |
| 196 | extern const efi_guid_t efi_guid_hii_config_access_protocol; |
Leif Lindholm | 5aab1b8 | 2019-01-21 12:12:57 +0900 | [diff] [blame] | 197 | extern const efi_guid_t efi_guid_hii_database_protocol; |
| 198 | extern const efi_guid_t efi_guid_hii_string_protocol; |
AKASHI Takahiro | 1faaca4 | 2020-04-14 11:51:39 +0900 | [diff] [blame] | 199 | /* GUIDs for authentication */ |
| 200 | extern const efi_guid_t efi_guid_image_security_database; |
| 201 | extern const efi_guid_t efi_guid_sha256; |
| 202 | extern const efi_guid_t efi_guid_cert_x509; |
| 203 | extern const efi_guid_t efi_guid_cert_x509_sha256; |
AKASHI Takahiro | b0f49ee | 2020-04-14 11:51:41 +0900 | [diff] [blame] | 204 | extern const efi_guid_t efi_guid_cert_type_pkcs7; |
Alexander Graf | 4e0c1c1 | 2016-03-04 01:09:58 +0100 | [diff] [blame] | 205 | |
Sughosh Ganu | 693a4f4 | 2019-12-29 00:01:06 +0530 | [diff] [blame] | 206 | /* GUID of RNG protocol */ |
| 207 | extern const efi_guid_t efi_guid_rng_protocol; |
| 208 | |
Alexander Graf | 0bd425a | 2016-03-04 01:10:01 +0100 | [diff] [blame] | 209 | extern unsigned int __efi_runtime_start, __efi_runtime_stop; |
| 210 | extern unsigned int __efi_runtime_rel_start, __efi_runtime_rel_stop; |
| 211 | |
Heinrich Schuchardt | 2e4b41f | 2019-05-21 17:51:35 +0200 | [diff] [blame] | 212 | /** |
| 213 | * struct efi_open_protocol_info_item - open protocol info item |
| 214 | * |
Heinrich Schuchardt | a277d3a | 2018-01-11 08:15:57 +0100 | [diff] [blame] | 215 | * When a protocol is opened a open protocol info entry is created. |
| 216 | * These are maintained in a list. |
Heinrich Schuchardt | 2e4b41f | 2019-05-21 17:51:35 +0200 | [diff] [blame] | 217 | * |
| 218 | * @link: link to the list of open protocol info entries of a protocol |
| 219 | * @info: information about the opening of a protocol |
Heinrich Schuchardt | a277d3a | 2018-01-11 08:15:57 +0100 | [diff] [blame] | 220 | */ |
| 221 | struct efi_open_protocol_info_item { |
Heinrich Schuchardt | a277d3a | 2018-01-11 08:15:57 +0100 | [diff] [blame] | 222 | struct list_head link; |
| 223 | struct efi_open_protocol_info_entry info; |
| 224 | }; |
| 225 | |
Heinrich Schuchardt | 2e4b41f | 2019-05-21 17:51:35 +0200 | [diff] [blame] | 226 | /** |
| 227 | * struct efi_handler - single protocol interface of a handle |
| 228 | * |
Alexander Graf | c15d921 | 2016-03-04 01:09:59 +0100 | [diff] [blame] | 229 | * When the UEFI payload wants to open a protocol on an object to get its |
| 230 | * interface (usually a struct with callback functions), this struct maps the |
Heinrich Schuchardt | a277d3a | 2018-01-11 08:15:57 +0100 | [diff] [blame] | 231 | * protocol GUID to the respective protocol interface |
Heinrich Schuchardt | 2e4b41f | 2019-05-21 17:51:35 +0200 | [diff] [blame] | 232 | * |
| 233 | * @link: link to the list of protocols of a handle |
| 234 | * @guid: GUID of the protocol |
| 235 | * @protocol_interface: protocol interface |
| 236 | * @open_infos link to the list of open protocol info items |
Heinrich Schuchardt | a277d3a | 2018-01-11 08:15:57 +0100 | [diff] [blame] | 237 | */ |
Alexander Graf | c15d921 | 2016-03-04 01:09:59 +0100 | [diff] [blame] | 238 | struct efi_handler { |
Heinrich Schuchardt | 99ce206 | 2017-11-26 14:05:17 +0100 | [diff] [blame] | 239 | struct list_head link; |
Alexander Graf | c15d921 | 2016-03-04 01:09:59 +0100 | [diff] [blame] | 240 | const efi_guid_t *guid; |
xypron.glpk@gmx.de | c35c924 | 2017-07-11 22:06:14 +0200 | [diff] [blame] | 241 | void *protocol_interface; |
Heinrich Schuchardt | a277d3a | 2018-01-11 08:15:57 +0100 | [diff] [blame] | 242 | struct list_head open_infos; |
Alexander Graf | c15d921 | 2016-03-04 01:09:59 +0100 | [diff] [blame] | 243 | }; |
| 244 | |
Heinrich Schuchardt | adb50d0 | 2018-09-26 05:27:55 +0200 | [diff] [blame] | 245 | /** |
Heinrich Schuchardt | b27ced4 | 2019-05-01 14:20:18 +0200 | [diff] [blame] | 246 | * enum efi_object_type - type of EFI object |
| 247 | * |
| 248 | * In UnloadImage we must be able to identify if the handle relates to a |
| 249 | * started image. |
| 250 | */ |
| 251 | enum efi_object_type { |
| 252 | EFI_OBJECT_TYPE_UNDEFINED = 0, |
Heinrich Schuchardt | 2e0a790 | 2019-05-05 16:55:06 +0200 | [diff] [blame] | 253 | EFI_OBJECT_TYPE_U_BOOT_FIRMWARE, |
Heinrich Schuchardt | b27ced4 | 2019-05-01 14:20:18 +0200 | [diff] [blame] | 254 | EFI_OBJECT_TYPE_LOADED_IMAGE, |
| 255 | EFI_OBJECT_TYPE_STARTED_IMAGE, |
| 256 | }; |
| 257 | |
| 258 | /** |
Heinrich Schuchardt | adb50d0 | 2018-09-26 05:27:55 +0200 | [diff] [blame] | 259 | * struct efi_object - dereferenced EFI handle |
| 260 | * |
| 261 | * @link: pointers to put the handle into a linked list |
| 262 | * @protocols: linked list with the protocol interfaces installed on this |
| 263 | * handle |
| 264 | * |
| 265 | * UEFI offers a flexible and expandable object model. The objects in the UEFI |
| 266 | * API are devices, drivers, and loaded images. struct efi_object is our storage |
| 267 | * structure for these objects. |
| 268 | * |
| 269 | * When including this structure into a larger structure always put it first so |
| 270 | * that when deleting a handle the whole encompassing structure can be freed. |
Alexander Graf | c15d921 | 2016-03-04 01:09:59 +0100 | [diff] [blame] | 271 | * |
Heinrich Schuchardt | adb50d0 | 2018-09-26 05:27:55 +0200 | [diff] [blame] | 272 | * A pointer to this structure is referred to as a handle. Typedef efi_handle_t |
| 273 | * has been created for such pointers. |
Alexander Graf | c15d921 | 2016-03-04 01:09:59 +0100 | [diff] [blame] | 274 | */ |
| 275 | struct efi_object { |
| 276 | /* Every UEFI object is part of a global object list */ |
| 277 | struct list_head link; |
Heinrich Schuchardt | 99ce206 | 2017-11-26 14:05:17 +0100 | [diff] [blame] | 278 | /* The list of protocols */ |
| 279 | struct list_head protocols; |
Heinrich Schuchardt | b27ced4 | 2019-05-01 14:20:18 +0200 | [diff] [blame] | 280 | enum efi_object_type type; |
Alexander Graf | c15d921 | 2016-03-04 01:09:59 +0100 | [diff] [blame] | 281 | }; |
| 282 | |
AKASHI Takahiro | 0e104e3 | 2020-04-14 11:51:44 +0900 | [diff] [blame] | 283 | enum efi_image_auth_status { |
| 284 | EFI_IMAGE_AUTH_FAILED = 0, |
| 285 | EFI_IMAGE_AUTH_PASSED, |
| 286 | }; |
| 287 | |
xypron.glpk@gmx.de | 3070823 | 2017-07-18 20:17:18 +0200 | [diff] [blame] | 288 | /** |
Heinrich Schuchardt | 3c3a735 | 2018-09-23 17:21:51 +0200 | [diff] [blame] | 289 | * struct efi_loaded_image_obj - handle of a loaded image |
Heinrich Schuchardt | 7292872 | 2018-09-26 05:27:56 +0200 | [diff] [blame] | 290 | * |
| 291 | * @header: EFI object header |
Heinrich Schuchardt | 3d44512 | 2019-04-30 17:57:30 +0200 | [diff] [blame] | 292 | * @exit_status: exit status passed to Exit() |
| 293 | * @exit_data_size: exit data size passed to Exit() |
| 294 | * @exit_data: exit data passed to Exit() |
Heinrich Schuchardt | 7292872 | 2018-09-26 05:27:56 +0200 | [diff] [blame] | 295 | * @exit_jmp: long jump buffer for returning form started image |
| 296 | * @entry: entry address of the relocated image |
Heinrich Schuchardt | 3c3a735 | 2018-09-23 17:21:51 +0200 | [diff] [blame] | 297 | */ |
| 298 | struct efi_loaded_image_obj { |
Heinrich Schuchardt | 7292872 | 2018-09-26 05:27:56 +0200 | [diff] [blame] | 299 | struct efi_object header; |
Heinrich Schuchardt | 3c3a735 | 2018-09-23 17:21:51 +0200 | [diff] [blame] | 300 | efi_status_t exit_status; |
Heinrich Schuchardt | 3d44512 | 2019-04-30 17:57:30 +0200 | [diff] [blame] | 301 | efi_uintn_t *exit_data_size; |
| 302 | u16 **exit_data; |
Heinrich Schuchardt | 3c3a735 | 2018-09-23 17:21:51 +0200 | [diff] [blame] | 303 | struct jmp_buf_data exit_jmp; |
| 304 | EFIAPI efi_status_t (*entry)(efi_handle_t image_handle, |
| 305 | struct efi_system_table *st); |
Heinrich Schuchardt | 3758752 | 2019-05-01 20:07:04 +0200 | [diff] [blame] | 306 | u16 image_type; |
AKASHI Takahiro | 0e104e3 | 2020-04-14 11:51:44 +0900 | [diff] [blame] | 307 | enum efi_image_auth_status auth_status; |
Heinrich Schuchardt | 3c3a735 | 2018-09-23 17:21:51 +0200 | [diff] [blame] | 308 | }; |
| 309 | |
| 310 | /** |
xypron.glpk@gmx.de | 3070823 | 2017-07-18 20:17:18 +0200 | [diff] [blame] | 311 | * struct efi_event |
| 312 | * |
Heinrich Schuchardt | 370c7a8 | 2018-02-18 15:17:50 +0100 | [diff] [blame] | 313 | * @link: Link to list of all events |
Heinrich Schuchardt | 35c0cf6 | 2019-06-05 21:00:39 +0200 | [diff] [blame] | 314 | * @queue_link: Link to the list of queued events |
xypron.glpk@gmx.de | 3070823 | 2017-07-18 20:17:18 +0200 | [diff] [blame] | 315 | * @type: Type of event, see efi_create_event |
| 316 | * @notify_tpl: Task priority level of notifications |
xypron.glpk@gmx.de | 3070823 | 2017-07-18 20:17:18 +0200 | [diff] [blame] | 317 | * @nofify_function: Function to call when the event is triggered |
| 318 | * @notify_context: Data to be passed to the notify function |
Heinrich Schuchardt | bf7f169 | 2018-02-18 15:17:52 +0100 | [diff] [blame] | 319 | * @group: Event group |
Heinrich Schuchardt | 370c7a8 | 2018-02-18 15:17:50 +0100 | [diff] [blame] | 320 | * @trigger_time: Period of the timer |
| 321 | * @trigger_next: Next time to trigger the timer |
xypron.glpk@gmx.de | 3070823 | 2017-07-18 20:17:18 +0200 | [diff] [blame] | 322 | * @trigger_type: Type of timer, see efi_set_timer |
Heinrich Schuchardt | 370c7a8 | 2018-02-18 15:17:50 +0100 | [diff] [blame] | 323 | * @is_signaled: The event occurred. The event is in the signaled state. |
xypron.glpk@gmx.de | 3070823 | 2017-07-18 20:17:18 +0200 | [diff] [blame] | 324 | */ |
| 325 | struct efi_event { |
Heinrich Schuchardt | 370c7a8 | 2018-02-18 15:17:50 +0100 | [diff] [blame] | 326 | struct list_head link; |
Heinrich Schuchardt | 35c0cf6 | 2019-06-05 21:00:39 +0200 | [diff] [blame] | 327 | struct list_head queue_link; |
xypron.glpk@gmx.de | 3ecc6bd | 2017-07-19 19:22:34 +0200 | [diff] [blame] | 328 | uint32_t type; |
Heinrich Schuchardt | f8d4ec3 | 2017-11-06 21:17:47 +0100 | [diff] [blame] | 329 | efi_uintn_t notify_tpl; |
xypron.glpk@gmx.de | 3070823 | 2017-07-18 20:17:18 +0200 | [diff] [blame] | 330 | void (EFIAPI *notify_function)(struct efi_event *event, void *context); |
| 331 | void *notify_context; |
Heinrich Schuchardt | bf7f169 | 2018-02-18 15:17:52 +0100 | [diff] [blame] | 332 | const efi_guid_t *group; |
xypron.glpk@gmx.de | 3070823 | 2017-07-18 20:17:18 +0200 | [diff] [blame] | 333 | u64 trigger_next; |
| 334 | u64 trigger_time; |
xypron.glpk@gmx.de | 3ecc6bd | 2017-07-19 19:22:34 +0200 | [diff] [blame] | 335 | enum efi_timer_delay trigger_type; |
Heinrich Schuchardt | 1bbee39 | 2017-10-04 15:03:24 +0200 | [diff] [blame] | 336 | bool is_signaled; |
xypron.glpk@gmx.de | 3070823 | 2017-07-18 20:17:18 +0200 | [diff] [blame] | 337 | }; |
| 338 | |
Alexander Graf | c15d921 | 2016-03-04 01:09:59 +0100 | [diff] [blame] | 339 | /* This list contains all UEFI objects we know of */ |
| 340 | extern struct list_head efi_obj_list; |
Heinrich Schuchardt | bf7f169 | 2018-02-18 15:17:52 +0100 | [diff] [blame] | 341 | /* List of all events */ |
| 342 | extern struct list_head efi_events; |
Alexander Graf | c15d921 | 2016-03-04 01:09:59 +0100 | [diff] [blame] | 343 | |
Heinrich Schuchardt | 6eec42d | 2019-05-04 17:27:54 +0200 | [diff] [blame] | 344 | /** |
Heinrich Schuchardt | d375e75 | 2019-05-21 18:19:01 +0200 | [diff] [blame] | 345 | * struct efi_protocol_notification - handle for notified protocol |
| 346 | * |
| 347 | * When a protocol interface is installed for which an event was registered with |
| 348 | * the RegisterProtocolNotify() service this structure is used to hold the |
| 349 | * handle on which the protocol interface was installed. |
| 350 | * |
| 351 | * @link: link to list of all handles notified for this event |
| 352 | * @handle: handle on which the notified protocol interface was installed |
| 353 | */ |
| 354 | struct efi_protocol_notification { |
| 355 | struct list_head link; |
| 356 | efi_handle_t handle; |
| 357 | }; |
| 358 | |
| 359 | /** |
Heinrich Schuchardt | 6eec42d | 2019-05-04 17:27:54 +0200 | [diff] [blame] | 360 | * efi_register_notify_event - event registered by RegisterProtocolNotify() |
| 361 | * |
| 362 | * The address of this structure serves as registration value. |
| 363 | * |
Heinrich Schuchardt | d375e75 | 2019-05-21 18:19:01 +0200 | [diff] [blame] | 364 | * @link: link to list of all registered events |
| 365 | * @event: registered event. The same event may registered for multiple |
| 366 | * GUIDs. |
| 367 | * @protocol: protocol for which the event is registered |
| 368 | * @handles: linked list of all handles on which the notified protocol was |
| 369 | * installed |
Heinrich Schuchardt | 6eec42d | 2019-05-04 17:27:54 +0200 | [diff] [blame] | 370 | */ |
| 371 | struct efi_register_notify_event { |
| 372 | struct list_head link; |
| 373 | struct efi_event *event; |
| 374 | efi_guid_t protocol; |
Heinrich Schuchardt | d375e75 | 2019-05-21 18:19:01 +0200 | [diff] [blame] | 375 | struct list_head handles; |
Heinrich Schuchardt | 6eec42d | 2019-05-04 17:27:54 +0200 | [diff] [blame] | 376 | }; |
| 377 | |
| 378 | /* List of all events registered by RegisterProtocolNotify() */ |
| 379 | extern struct list_head efi_register_notify_events; |
| 380 | |
AKASHI Takahiro | 7e0badb | 2018-12-30 15:16:55 +0100 | [diff] [blame] | 381 | /* Initialize efi execution environment */ |
| 382 | efi_status_t efi_init_obj_list(void); |
Heinrich Schuchardt | 6246741 | 2019-12-08 01:07:01 +0100 | [diff] [blame] | 383 | /* Install device tree */ |
| 384 | efi_status_t efi_install_fdt(void *fdt); |
Heinrich Schuchardt | ffb9059 | 2019-12-07 20:51:06 +0100 | [diff] [blame] | 385 | /* Run loaded UEFI image */ |
| 386 | efi_status_t efi_run_image(void *source_buffer, efi_uintn_t source_size); |
Heinrich Schuchardt | cf3b118 | 2019-06-20 13:52:16 +0200 | [diff] [blame] | 387 | /* Initialize variable services */ |
| 388 | efi_status_t efi_init_variables(void); |
Heinrich Schuchardt | 2ac6258 | 2019-06-20 15:25:48 +0200 | [diff] [blame] | 389 | /* Notify ExitBootServices() is called */ |
| 390 | void efi_variables_boot_exit_notify(void); |
Heinrich Schuchardt | 79d7202 | 2018-09-20 21:58:23 +0200 | [diff] [blame] | 391 | /* Called by bootefi to initialize root node */ |
| 392 | efi_status_t efi_root_node_register(void); |
Heinrich Schuchardt | 15070db | 2018-06-28 12:45:31 +0200 | [diff] [blame] | 393 | /* Called by bootefi to initialize runtime */ |
| 394 | efi_status_t efi_initialize_system_table(void); |
Heinrich Schuchardt | 1943dbb | 2019-07-05 17:42:16 +0200 | [diff] [blame] | 395 | /* efi_runtime_detach() - detach unimplemented runtime functions */ |
| 396 | void efi_runtime_detach(void); |
xypron.glpk@gmx.de | 54c7a8e | 2017-07-18 20:17:22 +0200 | [diff] [blame] | 397 | /* Called by bootefi to make console interface available */ |
Heinrich Schuchardt | a92e9ab | 2018-10-02 06:08:26 +0200 | [diff] [blame] | 398 | efi_status_t efi_console_register(void); |
Alexander Graf | e83be45 | 2016-03-04 01:10:02 +0100 | [diff] [blame] | 399 | /* Called by bootefi to make all disk storage accessible as EFI objects */ |
Heinrich Schuchardt | cde7a36 | 2018-02-09 20:55:47 +0100 | [diff] [blame] | 400 | efi_status_t efi_disk_register(void); |
Heinrich Schuchardt | 6f3de6b | 2018-01-19 20:24:47 +0100 | [diff] [blame] | 401 | /* Create handles and protocols for the partitions of a block device */ |
| 402 | int efi_disk_create_partitions(efi_handle_t parent, struct blk_desc *desc, |
| 403 | const char *if_typename, int diskid, |
| 404 | const char *pdevname); |
AKASHI Takahiro | 911df64 | 2020-04-27 18:48:20 +0900 | [diff] [blame] | 405 | /* Check if it is EFI system partition */ |
| 406 | bool efi_disk_is_system_part(efi_handle_t handle); |
Alexander Graf | d65783d | 2016-03-15 18:38:21 +0100 | [diff] [blame] | 407 | /* Called by bootefi to make GOP (graphical) interface available */ |
Heinrich Schuchardt | b91c084 | 2018-03-03 15:28:55 +0100 | [diff] [blame] | 408 | efi_status_t efi_gop_register(void); |
Alexander Graf | 94c4b99 | 2016-05-06 21:01:01 +0200 | [diff] [blame] | 409 | /* Called by bootefi to make the network interface available */ |
Heinrich Schuchardt | 6f5c73f | 2018-03-03 15:28:56 +0100 | [diff] [blame] | 410 | efi_status_t efi_net_register(void); |
Heinrich Schuchardt | 18081d4 | 2017-10-18 18:13:04 +0200 | [diff] [blame] | 411 | /* Called by bootefi to make the watchdog available */ |
Heinrich Schuchardt | f2704cc | 2018-03-03 15:28:57 +0100 | [diff] [blame] | 412 | efi_status_t efi_watchdog_register(void); |
Ilias Apalodimas | 3510ba7 | 2020-02-21 09:55:45 +0200 | [diff] [blame] | 413 | efi_status_t efi_initrd_register(void); |
Alexander Graf | 66f96e1 | 2016-08-19 01:23:29 +0200 | [diff] [blame] | 414 | /* Called by bootefi to make SMBIOS tables available */ |
Simon Glass | 2e2858f | 2018-05-16 09:42:19 -0600 | [diff] [blame] | 415 | /** |
Bin Meng | 2cfbdae | 2018-06-27 20:38:03 -0700 | [diff] [blame] | 416 | * efi_acpi_register() - write out ACPI tables |
| 417 | * |
| 418 | * Called by bootefi to make ACPI tables available |
| 419 | * |
| 420 | * @return 0 if OK, -ENOMEM if no memory is available for the tables |
| 421 | */ |
| 422 | efi_status_t efi_acpi_register(void); |
| 423 | /** |
Simon Glass | 2e2858f | 2018-05-16 09:42:19 -0600 | [diff] [blame] | 424 | * efi_smbios_register() - write out SMBIOS tables |
| 425 | * |
| 426 | * Called by bootefi to make SMBIOS tables available |
| 427 | * |
| 428 | * @return 0 if OK, -ENOMEM if no memory is available for the tables |
| 429 | */ |
Heinrich Schuchardt | 7a369c4 | 2018-03-03 15:28:54 +0100 | [diff] [blame] | 430 | efi_status_t efi_smbios_register(void); |
Alexander Graf | 94c4b99 | 2016-05-06 21:01:01 +0200 | [diff] [blame] | 431 | |
Rob Clark | 5314203 | 2017-09-13 18:05:34 -0400 | [diff] [blame] | 432 | struct efi_simple_file_system_protocol * |
| 433 | efi_fs_from_path(struct efi_device_path *fp); |
| 434 | |
Alexander Graf | 94c4b99 | 2016-05-06 21:01:01 +0200 | [diff] [blame] | 435 | /* Called by networking code to memorize the dhcp ack package */ |
| 436 | void efi_net_set_dhcp_ack(void *pkt, int len); |
Heinrich Schuchardt | 18081d4 | 2017-10-18 18:13:04 +0200 | [diff] [blame] | 437 | /* Called by efi_set_watchdog_timer to reset the timer */ |
| 438 | efi_status_t efi_set_watchdog(unsigned long timeout); |
Alexander Graf | 94c4b99 | 2016-05-06 21:01:01 +0200 | [diff] [blame] | 439 | |
Alexander Graf | c15d921 | 2016-03-04 01:09:59 +0100 | [diff] [blame] | 440 | /* Called from places to check whether a timer expired */ |
| 441 | void efi_timer_check(void); |
| 442 | /* PE loader implementation */ |
AKASHI Takahiro | 0e104e3 | 2020-04-14 11:51:44 +0900 | [diff] [blame] | 443 | efi_status_t efi_load_pe(struct efi_loaded_image_obj *handle, |
| 444 | void *efi, size_t efi_size, |
Heinrich Schuchardt | 408fbcc | 2018-12-26 12:49:09 +0100 | [diff] [blame] | 445 | struct efi_loaded_image *loaded_image_info); |
Alexander Graf | c15d921 | 2016-03-04 01:09:59 +0100 | [diff] [blame] | 446 | /* Called once to store the pristine gd pointer */ |
| 447 | void efi_save_gd(void); |
Rob Clark | 86789d5 | 2017-07-27 08:04:18 -0400 | [diff] [blame] | 448 | /* Special case handler for error/abort that just tries to dtrt to get |
| 449 | * back to u-boot world */ |
Alexander Graf | c15d921 | 2016-03-04 01:09:59 +0100 | [diff] [blame] | 450 | void efi_restore_gd(void); |
Alexander Graf | 0bd425a | 2016-03-04 01:10:01 +0100 | [diff] [blame] | 451 | /* Call this to relocate the runtime section to an address space */ |
| 452 | void efi_runtime_relocate(ulong offset, struct efi_mem_desc *map); |
Alexander Graf | 8f19f26 | 2016-03-04 01:10:14 +0100 | [diff] [blame] | 453 | /* Call this to set the current device name */ |
Alexander Graf | c49a1b8 | 2016-04-11 16:16:19 +0200 | [diff] [blame] | 454 | void efi_set_bootdev(const char *dev, const char *devnr, const char *path); |
Heinrich Schuchardt | 967d7de | 2017-11-26 14:05:23 +0100 | [diff] [blame] | 455 | /* Add a new object to the object list. */ |
Heinrich Schuchardt | adb50d0 | 2018-09-26 05:27:55 +0200 | [diff] [blame] | 456 | void efi_add_handle(efi_handle_t obj); |
Heinrich Schuchardt | eb6106e | 2017-10-26 19:25:49 +0200 | [diff] [blame] | 457 | /* Create handle */ |
Heinrich Schuchardt | b7cb8b4 | 2018-01-11 08:16:09 +0100 | [diff] [blame] | 458 | efi_status_t efi_create_handle(efi_handle_t *handle); |
Heinrich Schuchardt | 7d13546 | 2017-12-04 18:03:02 +0100 | [diff] [blame] | 459 | /* Delete handle */ |
Heinrich Schuchardt | adb50d0 | 2018-09-26 05:27:55 +0200 | [diff] [blame] | 460 | void efi_delete_handle(efi_handle_t obj); |
Heinrich Schuchardt | 274cc87 | 2017-11-06 21:17:50 +0100 | [diff] [blame] | 461 | /* Call this to validate a handle and find the EFI object for it */ |
Heinrich Schuchardt | b7cb8b4 | 2018-01-11 08:16:09 +0100 | [diff] [blame] | 462 | struct efi_object *efi_search_obj(const efi_handle_t handle); |
AKASHI Takahiro | b0ad905 | 2019-03-05 14:53:31 +0900 | [diff] [blame] | 463 | /* Load image */ |
| 464 | efi_status_t EFIAPI efi_load_image(bool boot_policy, |
| 465 | efi_handle_t parent_image, |
| 466 | struct efi_device_path *file_path, |
| 467 | void *source_buffer, |
| 468 | efi_uintn_t source_size, |
| 469 | efi_handle_t *image_handle); |
Heinrich Schuchardt | 2f8eb08 | 2018-12-26 13:28:09 +0100 | [diff] [blame] | 470 | /* Start image */ |
| 471 | efi_status_t EFIAPI efi_start_image(efi_handle_t image_handle, |
| 472 | efi_uintn_t *exit_data_size, |
| 473 | u16 **exit_data); |
AKASHI Takahiro | b0ad905 | 2019-03-05 14:53:31 +0900 | [diff] [blame] | 474 | /* Unload image */ |
| 475 | efi_status_t EFIAPI efi_unload_image(efi_handle_t image_handle); |
Heinrich Schuchardt | 5aef61d | 2017-10-26 19:25:53 +0200 | [diff] [blame] | 476 | /* Find a protocol on a handle */ |
Heinrich Schuchardt | b7cb8b4 | 2018-01-11 08:16:09 +0100 | [diff] [blame] | 477 | efi_status_t efi_search_protocol(const efi_handle_t handle, |
Heinrich Schuchardt | 5aef61d | 2017-10-26 19:25:53 +0200 | [diff] [blame] | 478 | const efi_guid_t *protocol_guid, |
| 479 | struct efi_handler **handler); |
| 480 | /* Install new protocol on a handle */ |
Heinrich Schuchardt | b7cb8b4 | 2018-01-11 08:16:09 +0100 | [diff] [blame] | 481 | efi_status_t efi_add_protocol(const efi_handle_t handle, |
| 482 | const efi_guid_t *protocol, |
Heinrich Schuchardt | 5aef61d | 2017-10-26 19:25:53 +0200 | [diff] [blame] | 483 | void *protocol_interface); |
| 484 | /* Delete protocol from a handle */ |
Heinrich Schuchardt | b7cb8b4 | 2018-01-11 08:16:09 +0100 | [diff] [blame] | 485 | efi_status_t efi_remove_protocol(const efi_handle_t handle, |
| 486 | const efi_guid_t *protocol, |
Heinrich Schuchardt | 5aef61d | 2017-10-26 19:25:53 +0200 | [diff] [blame] | 487 | void *protocol_interface); |
| 488 | /* Delete all protocols from a handle */ |
Heinrich Schuchardt | b7cb8b4 | 2018-01-11 08:16:09 +0100 | [diff] [blame] | 489 | efi_status_t efi_remove_all_protocols(const efi_handle_t handle); |
Heinrich Schuchardt | 744d83e | 2019-04-12 06:59:49 +0200 | [diff] [blame] | 490 | /* Install multiple protocol interfaces */ |
| 491 | efi_status_t EFIAPI efi_install_multiple_protocol_interfaces |
| 492 | (efi_handle_t *handle, ...); |
AKASHI Takahiro | d99b1b3 | 2020-03-17 11:12:36 +0900 | [diff] [blame] | 493 | /* Get handles that support a given protocol */ |
| 494 | efi_status_t EFIAPI efi_locate_handle_buffer( |
| 495 | enum efi_locate_search_type search_type, |
| 496 | const efi_guid_t *protocol, void *search_key, |
| 497 | efi_uintn_t *no_handles, efi_handle_t **buffer); |
| 498 | /* Close an previously opened protocol interface */ |
| 499 | efi_status_t EFIAPI efi_close_protocol(efi_handle_t handle, |
| 500 | const efi_guid_t *protocol, |
| 501 | efi_handle_t agent_handle, |
| 502 | efi_handle_t controller_handle); |
| 503 | /* Open a protocol interface */ |
| 504 | efi_status_t EFIAPI efi_handle_protocol(efi_handle_t handle, |
| 505 | const efi_guid_t *protocol, |
| 506 | void **protocol_interface); |
xypron.glpk@gmx.de | 852a0e177 | 2017-07-18 20:17:20 +0200 | [diff] [blame] | 507 | /* Call this to create an event */ |
Heinrich Schuchardt | f8d4ec3 | 2017-11-06 21:17:47 +0100 | [diff] [blame] | 508 | efi_status_t efi_create_event(uint32_t type, efi_uintn_t notify_tpl, |
xypron.glpk@gmx.de | 852a0e177 | 2017-07-18 20:17:20 +0200 | [diff] [blame] | 509 | void (EFIAPI *notify_function) ( |
| 510 | struct efi_event *event, |
| 511 | void *context), |
Heinrich Schuchardt | bf7f169 | 2018-02-18 15:17:52 +0100 | [diff] [blame] | 512 | void *notify_context, efi_guid_t *group, |
| 513 | struct efi_event **event); |
xypron.glpk@gmx.de | a587fd1 | 2017-07-18 20:17:21 +0200 | [diff] [blame] | 514 | /* Call this to set a timer */ |
xypron.glpk@gmx.de | 3ecc6bd | 2017-07-19 19:22:34 +0200 | [diff] [blame] | 515 | efi_status_t efi_set_timer(struct efi_event *event, enum efi_timer_delay type, |
xypron.glpk@gmx.de | a587fd1 | 2017-07-18 20:17:21 +0200 | [diff] [blame] | 516 | uint64_t trigger_time); |
xypron.glpk@gmx.de | 54c7a8e | 2017-07-18 20:17:22 +0200 | [diff] [blame] | 517 | /* Call this to signal an event */ |
Heinrich Schuchardt | 7b4b8d86 | 2019-06-07 06:47:01 +0200 | [diff] [blame] | 518 | void efi_signal_event(struct efi_event *event); |
Alexander Graf | 0bd425a | 2016-03-04 01:10:01 +0100 | [diff] [blame] | 519 | |
Rob Clark | 5314203 | 2017-09-13 18:05:34 -0400 | [diff] [blame] | 520 | /* open file system: */ |
| 521 | struct efi_simple_file_system_protocol *efi_simple_file_system( |
| 522 | struct blk_desc *desc, int part, struct efi_device_path *dp); |
| 523 | |
| 524 | /* open file from device-path: */ |
| 525 | struct efi_file_handle *efi_file_from_path(struct efi_device_path *fp); |
| 526 | |
Heinrich Schuchardt | dcdca29 | 2018-11-18 17:58:49 +0100 | [diff] [blame] | 527 | /** |
| 528 | * efi_size_in_pages() - convert size in bytes to size in pages |
| 529 | * |
| 530 | * This macro returns the number of EFI memory pages required to hold 'size' |
| 531 | * bytes. |
| 532 | * |
| 533 | * @size: size in bytes |
| 534 | * Return: size in pages |
| 535 | */ |
| 536 | #define efi_size_in_pages(size) ((size + EFI_PAGE_MASK) >> EFI_PAGE_SHIFT) |
Alexander Graf | 8623f92 | 2016-03-04 01:10:04 +0100 | [diff] [blame] | 537 | /* Generic EFI memory allocator, call this to get memory */ |
| 538 | void *efi_alloc(uint64_t len, int memory_type); |
| 539 | /* More specific EFI memory allocator, called by EFI payloads */ |
Heinrich Schuchardt | 798a441 | 2017-11-06 21:17:48 +0100 | [diff] [blame] | 540 | efi_status_t efi_allocate_pages(int type, int memory_type, efi_uintn_t pages, |
Alexander Graf | 8623f92 | 2016-03-04 01:10:04 +0100 | [diff] [blame] | 541 | uint64_t *memory); |
Stefan Brüns | a4f4302 | 2016-10-01 23:32:27 +0200 | [diff] [blame] | 542 | /* EFI memory free function. */ |
Heinrich Schuchardt | 798a441 | 2017-11-06 21:17:48 +0100 | [diff] [blame] | 543 | efi_status_t efi_free_pages(uint64_t memory, efi_uintn_t pages); |
Stefan Brüns | 5a09aef | 2016-10-09 22:17:18 +0200 | [diff] [blame] | 544 | /* EFI memory allocator for small allocations */ |
Heinrich Schuchardt | 798a441 | 2017-11-06 21:17:48 +0100 | [diff] [blame] | 545 | efi_status_t efi_allocate_pool(int pool_type, efi_uintn_t size, |
Stefan Brüns | 5a09aef | 2016-10-09 22:17:18 +0200 | [diff] [blame] | 546 | void **buffer); |
Stefan Brüns | 67b67d9 | 2016-10-09 22:17:26 +0200 | [diff] [blame] | 547 | /* EFI pool memory free function. */ |
| 548 | efi_status_t efi_free_pool(void *buffer); |
Alexander Graf | 8623f92 | 2016-03-04 01:10:04 +0100 | [diff] [blame] | 549 | /* Returns the EFI memory map */ |
Heinrich Schuchardt | 798a441 | 2017-11-06 21:17:48 +0100 | [diff] [blame] | 550 | efi_status_t efi_get_memory_map(efi_uintn_t *memory_map_size, |
Alexander Graf | 8623f92 | 2016-03-04 01:10:04 +0100 | [diff] [blame] | 551 | struct efi_mem_desc *memory_map, |
Heinrich Schuchardt | 798a441 | 2017-11-06 21:17:48 +0100 | [diff] [blame] | 552 | efi_uintn_t *map_key, |
| 553 | efi_uintn_t *descriptor_size, |
Alexander Graf | 8623f92 | 2016-03-04 01:10:04 +0100 | [diff] [blame] | 554 | uint32_t *descriptor_version); |
| 555 | /* Adds a range into the EFI memory map */ |
Michael Walle | 282d386 | 2020-05-17 12:29:19 +0200 | [diff] [blame] | 556 | efi_status_t efi_add_memory_map(u64 start, u64 size, int memory_type); |
Park, Aiden | e009e7a | 2019-09-03 17:43:43 +0000 | [diff] [blame] | 557 | /* Adds a conventional range into the EFI memory map */ |
| 558 | efi_status_t efi_add_conventional_memory_map(u64 ram_start, u64 ram_end, |
| 559 | u64 ram_top); |
| 560 | |
Heinrich Schuchardt | 11206f4 | 2018-01-21 19:29:30 +0100 | [diff] [blame] | 561 | /* Called by board init to initialize the EFI drivers */ |
Heinrich Schuchardt | 8f3cc5b | 2018-02-01 12:53:32 +0100 | [diff] [blame] | 562 | efi_status_t efi_driver_init(void); |
Alexander Graf | 8623f92 | 2016-03-04 01:10:04 +0100 | [diff] [blame] | 563 | /* Called by board init to initialize the EFI memory map */ |
| 564 | int efi_memory_init(void); |
Alexander Graf | c5c1163 | 2016-08-19 01:23:24 +0200 | [diff] [blame] | 565 | /* Adds new or overrides configuration table entry to the system table */ |
| 566 | efi_status_t efi_install_configuration_table(const efi_guid_t *guid, void *table); |
Heinrich Schuchardt | 7db9f89 | 2017-12-04 18:03:01 +0100 | [diff] [blame] | 567 | /* Sets up a loaded image */ |
Heinrich Schuchardt | 3c3a735 | 2018-09-23 17:21:51 +0200 | [diff] [blame] | 568 | efi_status_t efi_setup_loaded_image(struct efi_device_path *device_path, |
| 569 | struct efi_device_path *file_path, |
| 570 | struct efi_loaded_image_obj **handle_ptr, |
| 571 | struct efi_loaded_image **info_ptr); |
Heinrich Schuchardt | 83d96b7 | 2018-04-05 11:56:21 +0200 | [diff] [blame] | 572 | /* Print information about all loaded images */ |
| 573 | void efi_print_image_infos(void *pc); |
Alexander Graf | 8623f92 | 2016-03-04 01:10:04 +0100 | [diff] [blame] | 574 | |
Alexander Graf | 7c00a3c | 2016-05-11 18:25:48 +0200 | [diff] [blame] | 575 | #ifdef CONFIG_EFI_LOADER_BOUNCE_BUFFER |
| 576 | extern void *efi_bounce_buffer; |
| 577 | #define EFI_LOADER_BOUNCE_BUFFER_SIZE (64 * 1024 * 1024) |
| 578 | #endif |
| 579 | |
Rob Clark | f90cb9f | 2017-09-13 18:05:28 -0400 | [diff] [blame] | 580 | |
| 581 | struct efi_device_path *efi_dp_next(const struct efi_device_path *dp); |
Heinrich Schuchardt | 753e248 | 2017-10-26 19:25:48 +0200 | [diff] [blame] | 582 | int efi_dp_match(const struct efi_device_path *a, |
| 583 | const struct efi_device_path *b); |
Rob Clark | f90cb9f | 2017-09-13 18:05:28 -0400 | [diff] [blame] | 584 | struct efi_object *efi_dp_find_obj(struct efi_device_path *dp, |
| 585 | struct efi_device_path **rem); |
Heinrich Schuchardt | 51ca4f5 | 2018-04-16 07:59:08 +0200 | [diff] [blame] | 586 | /* get size of the first device path instance excluding end node */ |
| 587 | efi_uintn_t efi_dp_instance_size(const struct efi_device_path *dp); |
| 588 | /* size of multi-instance device path excluding end node */ |
| 589 | efi_uintn_t efi_dp_size(const struct efi_device_path *dp); |
Rob Clark | f90cb9f | 2017-09-13 18:05:28 -0400 | [diff] [blame] | 590 | struct efi_device_path *efi_dp_dup(const struct efi_device_path *dp); |
| 591 | struct efi_device_path *efi_dp_append(const struct efi_device_path *dp1, |
| 592 | const struct efi_device_path *dp2); |
| 593 | struct efi_device_path *efi_dp_append_node(const struct efi_device_path *dp, |
| 594 | const struct efi_device_path *node); |
Heinrich Schuchardt | b41c8e2 | 2018-04-16 07:59:05 +0200 | [diff] [blame] | 595 | /* Create a device path node of given type, sub-type, length */ |
| 596 | struct efi_device_path *efi_dp_create_device_node(const u8 type, |
| 597 | const u8 sub_type, |
| 598 | const u16 length); |
Heinrich Schuchardt | cb0f7ce | 2018-04-16 07:59:09 +0200 | [diff] [blame] | 599 | /* Append device path instance */ |
| 600 | struct efi_device_path *efi_dp_append_instance( |
| 601 | const struct efi_device_path *dp, |
| 602 | const struct efi_device_path *dpi); |
| 603 | /* Get next device path instance */ |
| 604 | struct efi_device_path *efi_dp_get_next_instance(struct efi_device_path **dp, |
| 605 | efi_uintn_t *size); |
| 606 | /* Check if a device path contains muliple instances */ |
| 607 | bool efi_dp_is_multi_instance(const struct efi_device_path *dp); |
Rob Clark | f90cb9f | 2017-09-13 18:05:28 -0400 | [diff] [blame] | 608 | |
Rob Clark | f90cb9f | 2017-09-13 18:05:28 -0400 | [diff] [blame] | 609 | struct efi_device_path *efi_dp_from_part(struct blk_desc *desc, int part); |
Heinrich Schuchardt | 6c6307c | 2018-01-19 20:24:46 +0100 | [diff] [blame] | 610 | /* Create a device node for a block device partition. */ |
| 611 | struct efi_device_path *efi_dp_part_node(struct blk_desc *desc, int part); |
Rob Clark | f90cb9f | 2017-09-13 18:05:28 -0400 | [diff] [blame] | 612 | struct efi_device_path *efi_dp_from_file(struct blk_desc *desc, int part, |
| 613 | const char *path); |
| 614 | struct efi_device_path *efi_dp_from_eth(void); |
Rob Clark | 18ceba7 | 2017-10-10 08:23:06 -0400 | [diff] [blame] | 615 | struct efi_device_path *efi_dp_from_mem(uint32_t mem_type, |
| 616 | uint64_t start_address, |
| 617 | uint64_t end_address); |
Heinrich Schuchardt | 0976f8b | 2018-01-19 20:24:49 +0100 | [diff] [blame] | 618 | /* Determine the last device path node that is not the end node. */ |
| 619 | const struct efi_device_path *efi_dp_last_node( |
| 620 | const struct efi_device_path *dp); |
Heinrich Schuchardt | 468bf97 | 2018-01-19 20:24:37 +0100 | [diff] [blame] | 621 | efi_status_t efi_dp_split_file_path(struct efi_device_path *full_path, |
| 622 | struct efi_device_path **device_path, |
| 623 | struct efi_device_path **file_path); |
AKASHI Takahiro | 035fb01 | 2018-10-17 16:32:03 +0900 | [diff] [blame] | 624 | efi_status_t efi_dp_from_name(const char *dev, const char *devnr, |
| 625 | const char *path, |
| 626 | struct efi_device_path **device, |
| 627 | struct efi_device_path **file); |
Rob Clark | f90cb9f | 2017-09-13 18:05:28 -0400 | [diff] [blame] | 628 | |
| 629 | #define EFI_DP_TYPE(_dp, _type, _subtype) \ |
| 630 | (((_dp)->type == DEVICE_PATH_TYPE_##_type) && \ |
| 631 | ((_dp)->sub_type == DEVICE_PATH_SUB_TYPE_##_subtype)) |
| 632 | |
Alexander Graf | 0bd425a | 2016-03-04 01:10:01 +0100 | [diff] [blame] | 633 | /* |
| 634 | * Use these to indicate that your code / data should go into the EFI runtime |
| 635 | * section and thus still be available when the OS is running |
| 636 | */ |
Alexander Graf | 94a10f2 | 2018-06-12 07:48:37 +0200 | [diff] [blame] | 637 | #define __efi_runtime_data __attribute__ ((section (".data.efi_runtime"))) |
| 638 | #define __efi_runtime __attribute__ ((section (".text.efi_runtime"))) |
Alexander Graf | c15d921 | 2016-03-04 01:09:59 +0100 | [diff] [blame] | 639 | |
AKASHI Takahiro | 3240184 | 2019-06-05 13:21:38 +0900 | [diff] [blame] | 640 | /* Indicate supported runtime services */ |
| 641 | efi_status_t efi_init_runtime_supported(void); |
| 642 | |
Heinrich Schuchardt | 69c1576 | 2018-07-29 09:49:04 +0200 | [diff] [blame] | 643 | /* Update CRC32 in table header */ |
| 644 | void __efi_runtime efi_update_table_header_crc32(struct efi_table_hdr *table); |
| 645 | |
Alexander Graf | 7725609 | 2016-08-16 21:08:45 +0200 | [diff] [blame] | 646 | /* Call this with mmio_ptr as the _pointer_ to a pointer to an MMIO region |
| 647 | * to make it available at runtime */ |
Heinrich Schuchardt | 099b3b7 | 2018-03-03 15:28:59 +0100 | [diff] [blame] | 648 | efi_status_t efi_add_runtime_mmio(void *mmio_ptr, u64 len); |
Alexander Graf | 7725609 | 2016-08-16 21:08:45 +0200 | [diff] [blame] | 649 | |
| 650 | /* Boards may provide the functions below to implement RTS functionality */ |
| 651 | |
Alexander Graf | 393dd91 | 2016-10-14 13:45:30 +0200 | [diff] [blame] | 652 | void __efi_runtime EFIAPI efi_reset_system( |
Alexander Graf | 7725609 | 2016-08-16 21:08:45 +0200 | [diff] [blame] | 653 | enum efi_reset_type reset_type, |
| 654 | efi_status_t reset_status, |
| 655 | unsigned long data_size, void *reset_data); |
Heinrich Schuchardt | 099b3b7 | 2018-03-03 15:28:59 +0100 | [diff] [blame] | 656 | |
| 657 | /* Architecture specific initialization of the EFI subsystem */ |
| 658 | efi_status_t efi_reset_system_init(void); |
Alexander Graf | 7725609 | 2016-08-16 21:08:45 +0200 | [diff] [blame] | 659 | |
Alexander Graf | 393dd91 | 2016-10-14 13:45:30 +0200 | [diff] [blame] | 660 | efi_status_t __efi_runtime EFIAPI efi_get_time( |
Alexander Graf | 7725609 | 2016-08-16 21:08:45 +0200 | [diff] [blame] | 661 | struct efi_time *time, |
| 662 | struct efi_time_cap *capabilities); |
Alexander Graf | 7725609 | 2016-08-16 21:08:45 +0200 | [diff] [blame] | 663 | |
Heinrich Schuchardt | 289121e | 2019-05-31 07:38:29 +0200 | [diff] [blame] | 664 | efi_status_t __efi_runtime EFIAPI efi_set_time(struct efi_time *time); |
| 665 | |
Heinrich Schuchardt | d33ae3e | 2017-09-15 10:06:11 +0200 | [diff] [blame] | 666 | #ifdef CONFIG_CMD_BOOTEFI_SELFTEST |
| 667 | /* |
| 668 | * Entry point for the tests of the EFI API. |
| 669 | * It is called by 'bootefi selftest' |
| 670 | */ |
| 671 | efi_status_t EFIAPI efi_selftest(efi_handle_t image_handle, |
| 672 | struct efi_system_table *systab); |
| 673 | #endif |
| 674 | |
Heinrich Schuchardt | e06ae19 | 2018-12-30 20:53:51 +0100 | [diff] [blame] | 675 | efi_status_t EFIAPI efi_get_variable(u16 *variable_name, |
| 676 | const efi_guid_t *vendor, u32 *attributes, |
| 677 | efi_uintn_t *data_size, void *data); |
Heinrich Schuchardt | d6a6baa | 2018-05-17 07:57:05 +0200 | [diff] [blame] | 678 | efi_status_t EFIAPI efi_get_next_variable_name(efi_uintn_t *variable_name_size, |
| 679 | u16 *variable_name, |
Heinrich Schuchardt | 82cd6c4 | 2020-03-22 18:28:20 +0100 | [diff] [blame] | 680 | efi_guid_t *vendor); |
Heinrich Schuchardt | e06ae19 | 2018-12-30 20:53:51 +0100 | [diff] [blame] | 681 | efi_status_t EFIAPI efi_set_variable(u16 *variable_name, |
| 682 | const efi_guid_t *vendor, u32 attributes, |
Heinrich Schuchardt | 73e2ab0 | 2018-12-30 21:03:15 +0100 | [diff] [blame] | 683 | efi_uintn_t data_size, const void *data); |
Rob Clark | 15f3d74 | 2017-09-13 18:05:37 -0400 | [diff] [blame] | 684 | |
Heinrich Schuchardt | 9b19dae | 2019-06-20 12:13:05 +0200 | [diff] [blame] | 685 | efi_status_t EFIAPI efi_query_variable_info( |
| 686 | u32 attributes, u64 *maximum_variable_storage_size, |
| 687 | u64 *remaining_variable_storage_size, |
| 688 | u64 *maximum_variable_size); |
| 689 | |
AKASHI Takahiro | bd23774 | 2018-11-05 18:06:41 +0900 | [diff] [blame] | 690 | /* |
| 691 | * See section 3.1.3 in the v2.7 UEFI spec for more details on |
| 692 | * the layout of EFI_LOAD_OPTION. In short it is: |
| 693 | * |
| 694 | * typedef struct _EFI_LOAD_OPTION { |
| 695 | * UINT32 Attributes; |
| 696 | * UINT16 FilePathListLength; |
| 697 | * // CHAR16 Description[]; <-- variable length, NULL terminated |
| 698 | * // EFI_DEVICE_PATH_PROTOCOL FilePathList[]; |
| 699 | * <-- FilePathListLength bytes |
| 700 | * // UINT8 OptionalData[]; |
| 701 | * } EFI_LOAD_OPTION; |
| 702 | */ |
| 703 | struct efi_load_option { |
| 704 | u32 attributes; |
| 705 | u16 file_path_length; |
| 706 | u16 *label; |
| 707 | struct efi_device_path *file_path; |
Heinrich Schuchardt | 9df002e | 2019-04-29 13:51:45 +0200 | [diff] [blame] | 708 | const u8 *optional_data; |
AKASHI Takahiro | bd23774 | 2018-11-05 18:06:41 +0900 | [diff] [blame] | 709 | }; |
| 710 | |
Heinrich Schuchardt | 7ca84f8 | 2020-05-31 22:46:09 +0200 | [diff] [blame] | 711 | efi_status_t efi_deserialize_load_option(struct efi_load_option *lo, u8 *data, |
| 712 | efi_uintn_t *size); |
AKASHI Takahiro | bd23774 | 2018-11-05 18:06:41 +0900 | [diff] [blame] | 713 | unsigned long efi_serialize_load_option(struct efi_load_option *lo, u8 **data); |
AKASHI Takahiro | 14ff23b | 2019-04-19 12:22:35 +0900 | [diff] [blame] | 714 | efi_status_t efi_bootmgr_load(efi_handle_t *handle); |
Rob Clark | c84c110 | 2017-09-13 18:05:38 -0400 | [diff] [blame] | 715 | |
AKASHI Takahiro | 1faaca4 | 2020-04-14 11:51:39 +0900 | [diff] [blame] | 716 | /** |
| 717 | * efi_image_regions - A list of memory regions |
| 718 | * |
| 719 | * @max: Maximum number of regions |
| 720 | * @num: Number of regions |
| 721 | * @reg: array of regions |
| 722 | */ |
| 723 | struct efi_image_regions { |
| 724 | int max; |
| 725 | int num; |
| 726 | struct image_region reg[]; |
| 727 | }; |
| 728 | |
| 729 | /** |
| 730 | * efi_sig_data - A decoded data of struct efi_signature_data |
| 731 | * |
| 732 | * This structure represents an internal form of signature in |
| 733 | * signature database. A listed list may represent a signature list. |
| 734 | * |
| 735 | * @next: Pointer to next entry |
| 736 | * @onwer: Signature owner |
| 737 | * @data: Pointer to signature data |
| 738 | * @size: Size of signature data |
| 739 | */ |
| 740 | struct efi_sig_data { |
| 741 | struct efi_sig_data *next; |
| 742 | efi_guid_t owner; |
| 743 | void *data; |
| 744 | size_t size; |
| 745 | }; |
| 746 | |
| 747 | /** |
| 748 | * efi_signature_store - A decoded data of signature database |
| 749 | * |
| 750 | * This structure represents an internal form of signature database. |
| 751 | * |
| 752 | * @next: Pointer to next entry |
| 753 | * @sig_type: Signature type |
| 754 | * @sig_data_list: Pointer to signature list |
| 755 | */ |
| 756 | struct efi_signature_store { |
| 757 | struct efi_signature_store *next; |
| 758 | efi_guid_t sig_type; |
| 759 | struct efi_sig_data *sig_data_list; |
| 760 | }; |
| 761 | |
| 762 | struct x509_certificate; |
| 763 | struct pkcs7_message; |
| 764 | |
| 765 | bool efi_signature_verify_cert(struct x509_certificate *cert, |
| 766 | struct efi_signature_store *dbx); |
| 767 | bool efi_signature_verify_signers(struct pkcs7_message *msg, |
| 768 | struct efi_signature_store *dbx); |
| 769 | bool efi_signature_verify_with_sigdb(struct efi_image_regions *regs, |
| 770 | struct pkcs7_message *msg, |
| 771 | struct efi_signature_store *db, |
| 772 | struct x509_certificate **cert); |
| 773 | |
| 774 | efi_status_t efi_image_region_add(struct efi_image_regions *regs, |
| 775 | const void *start, const void *end, |
| 776 | int nocheck); |
AKASHI Takahiro | d2cefc8 | 2020-04-14 11:51:40 +0900 | [diff] [blame] | 777 | |
| 778 | void efi_sigstore_free(struct efi_signature_store *sigstore); |
| 779 | struct efi_signature_store *efi_sigstore_parse_sigdb(u16 *name); |
AKASHI Takahiro | b0f49ee | 2020-04-14 11:51:41 +0900 | [diff] [blame] | 780 | |
| 781 | bool efi_secure_boot_enabled(void); |
AKASHI Takahiro | 0e104e3 | 2020-04-14 11:51:44 +0900 | [diff] [blame] | 782 | |
| 783 | bool efi_image_parse(void *efi, size_t len, struct efi_image_regions **regp, |
| 784 | WIN_CERTIFICATE **auth, size_t *auth_len); |
AKASHI Takahiro | 1faaca4 | 2020-04-14 11:51:39 +0900 | [diff] [blame] | 785 | |
Stephen Warren | d0de806 | 2018-08-30 15:43:43 -0600 | [diff] [blame] | 786 | #else /* CONFIG_IS_ENABLED(EFI_LOADER) */ |
Alexander Graf | c15d921 | 2016-03-04 01:09:59 +0100 | [diff] [blame] | 787 | |
Alexander Graf | 0bd425a | 2016-03-04 01:10:01 +0100 | [diff] [blame] | 788 | /* Without CONFIG_EFI_LOADER we don't have a runtime section, stub it out */ |
Alexander Graf | 393dd91 | 2016-10-14 13:45:30 +0200 | [diff] [blame] | 789 | #define __efi_runtime_data |
| 790 | #define __efi_runtime |
Heinrich Schuchardt | 099b3b7 | 2018-03-03 15:28:59 +0100 | [diff] [blame] | 791 | static inline efi_status_t efi_add_runtime_mmio(void *mmio_ptr, u64 len) |
| 792 | { |
| 793 | return EFI_SUCCESS; |
| 794 | } |
Alexander Graf | 0bd425a | 2016-03-04 01:10:01 +0100 | [diff] [blame] | 795 | |
Alexander Graf | c15d921 | 2016-03-04 01:09:59 +0100 | [diff] [blame] | 796 | /* No loader configured, stub out EFI_ENTRY */ |
| 797 | static inline void efi_restore_gd(void) { } |
Alexander Graf | c49a1b8 | 2016-04-11 16:16:19 +0200 | [diff] [blame] | 798 | static inline void efi_set_bootdev(const char *dev, const char *devnr, |
| 799 | const char *path) { } |
Alexander Graf | 94c4b99 | 2016-05-06 21:01:01 +0200 | [diff] [blame] | 800 | static inline void efi_net_set_dhcp_ack(void *pkt, int len) { } |
Heinrich Schuchardt | 83d96b7 | 2018-04-05 11:56:21 +0200 | [diff] [blame] | 801 | static inline void efi_print_image_infos(void *pc) { } |
Alexander Graf | c15d921 | 2016-03-04 01:09:59 +0100 | [diff] [blame] | 802 | |
Stephen Warren | d0de806 | 2018-08-30 15:43:43 -0600 | [diff] [blame] | 803 | #endif /* CONFIG_IS_ENABLED(EFI_LOADER) */ |
Heinrich Schuchardt | c2fd477 | 2017-10-18 18:13:07 +0200 | [diff] [blame] | 804 | |
| 805 | #endif /* _EFI_LOADER_H */ |