Tom Rini | f739fcd | 2018-05-07 17:02:21 -0400 | [diff] [blame] | 1 | /* SPDX-License-Identifier: GPL-2.0+ */ |
Alexander Graf | cb149c6 | 2016-03-04 01:09:58 +0100 | [diff] [blame] | 2 | /* |
| 3 | * EFI application loader |
| 4 | * |
| 5 | * Copyright (c) 2016 Alexander Graf |
Alexander Graf | cb149c6 | 2016-03-04 01:09:58 +0100 | [diff] [blame] | 6 | */ |
| 7 | |
Heinrich Schuchardt | cd9e18d | 2017-10-18 18:13:07 +0200 | [diff] [blame] | 8 | #ifndef _EFI_LOADER_H |
| 9 | #define _EFI_LOADER_H 1 |
| 10 | |
Simon Glass | e6f6f9e | 2020-05-10 11:39:58 -0600 | [diff] [blame] | 11 | #include <blk.h> |
Heinrich Schuchardt | f05911a | 2022-10-06 07:29:41 +0200 | [diff] [blame] | 12 | #include <event.h> |
Simon Glass | f7ae49f | 2020-05-10 11:40:05 -0600 | [diff] [blame] | 13 | #include <log.h> |
Alexander Graf | cb149c6 | 2016-03-04 01:09:58 +0100 | [diff] [blame] | 14 | #include <part_efi.h> |
| 15 | #include <efi_api.h> |
AKASHI Takahiro | d9f3307 | 2020-04-21 09:38:38 +0900 | [diff] [blame] | 16 | #include <image.h> |
AKASHI Takahiro | 4540dab | 2020-04-14 11:51:44 +0900 | [diff] [blame] | 17 | #include <pe.h> |
Simon Glass | 6e3c654 | 2021-07-02 12:36:16 -0600 | [diff] [blame] | 18 | #include <linux/list.h> |
| 19 | #include <linux/oid_registry.h> |
Alexander Graf | bee9116 | 2016-03-04 01:09:59 +0100 | [diff] [blame] | 20 | |
Simon Glass | e6f6f9e | 2020-05-10 11:39:58 -0600 | [diff] [blame] | 21 | struct blk_desc; |
AKASHI Takahiro | 86a3d43 | 2021-07-20 14:57:02 +0900 | [diff] [blame] | 22 | struct jmp_buf_data; |
Simon Glass | e6f6f9e | 2020-05-10 11:39:58 -0600 | [diff] [blame] | 23 | |
Simon Glass | fdeb6f7 | 2019-09-25 08:11:32 -0600 | [diff] [blame] | 24 | static inline int guidcmp(const void *g1, const void *g2) |
| 25 | { |
| 26 | return memcmp(g1, g2, sizeof(efi_guid_t)); |
| 27 | } |
| 28 | |
Sughosh Ganu | 61e42d9 | 2019-12-29 00:01:04 +0530 | [diff] [blame] | 29 | static inline void *guidcpy(void *dst, const void *src) |
| 30 | { |
| 31 | return memcpy(dst, src, sizeof(efi_guid_t)); |
| 32 | } |
| 33 | |
Stephen Warren | 9b5e639 | 2018-08-30 15:43:43 -0600 | [diff] [blame] | 34 | #if CONFIG_IS_ENABLED(EFI_LOADER) |
Alexander Graf | bee9116 | 2016-03-04 01:09:59 +0100 | [diff] [blame] | 35 | |
Simon Glass | 6e3c654 | 2021-07-02 12:36:16 -0600 | [diff] [blame] | 36 | /** |
| 37 | * __efi_runtime_data - declares a non-const variable for EFI runtime section |
| 38 | * |
| 39 | * This macro indicates that a variable is non-const and should go into the |
| 40 | * EFI runtime section, and thus still be available when the OS is running. |
| 41 | * |
| 42 | * Only use on variables not declared const. |
| 43 | * |
| 44 | * Example: |
| 45 | * |
| 46 | * :: |
| 47 | * |
| 48 | * static __efi_runtime_data my_computed_table[256]; |
| 49 | */ |
| 50 | #define __efi_runtime_data __section(".data.efi_runtime") |
| 51 | |
| 52 | /** |
| 53 | * __efi_runtime_rodata - declares a read-only variable for EFI runtime section |
| 54 | * |
| 55 | * This macro indicates that a variable is read-only (const) and should go into |
| 56 | * the EFI runtime section, and thus still be available when the OS is running. |
| 57 | * |
| 58 | * Only use on variables also declared const. |
| 59 | * |
| 60 | * Example: |
| 61 | * |
| 62 | * :: |
| 63 | * |
| 64 | * static const __efi_runtime_rodata my_const_table[] = { 1, 2, 3 }; |
| 65 | */ |
| 66 | #define __efi_runtime_rodata __section(".rodata.efi_runtime") |
| 67 | |
| 68 | /** |
| 69 | * __efi_runtime - declares a function for EFI runtime section |
| 70 | * |
| 71 | * This macro indicates that a function should go into the EFI runtime section, |
| 72 | * and thus still be available when the OS is running. |
| 73 | * |
| 74 | * Example: |
| 75 | * |
| 76 | * :: |
| 77 | * |
| 78 | * static __efi_runtime compute_my_table(void); |
| 79 | */ |
| 80 | #define __efi_runtime __section(".text.efi_runtime") |
| 81 | |
| 82 | /* |
| 83 | * Call this with mmio_ptr as the _pointer_ to a pointer to an MMIO region |
| 84 | * to make it available at runtime |
| 85 | */ |
| 86 | efi_status_t efi_add_runtime_mmio(void *mmio_ptr, u64 len); |
| 87 | |
| 88 | /* |
| 89 | * Special case handler for error/abort that just tries to dtrt to get |
| 90 | * back to u-boot world |
| 91 | */ |
| 92 | void efi_restore_gd(void); |
AKASHI Takahiro | 6422820 | 2024-01-17 13:39:41 +0900 | [diff] [blame] | 93 | |
Simon Glass | 6e3c654 | 2021-07-02 12:36:16 -0600 | [diff] [blame] | 94 | /* Called by networking code to memorize the dhcp ack package */ |
| 95 | void efi_net_set_dhcp_ack(void *pkt, int len); |
| 96 | /* Print information about all loaded images */ |
| 97 | void efi_print_image_infos(void *pc); |
| 98 | |
| 99 | /* Hook at initialization */ |
| 100 | efi_status_t efi_launch_capsules(void); |
| 101 | |
| 102 | #else /* CONFIG_IS_ENABLED(EFI_LOADER) */ |
| 103 | |
| 104 | /* Without CONFIG_EFI_LOADER we don't have a runtime section, stub it out */ |
| 105 | #define __efi_runtime_data |
| 106 | #define __efi_runtime_rodata |
| 107 | #define __efi_runtime |
| 108 | static inline efi_status_t efi_add_runtime_mmio(void *mmio_ptr, u64 len) |
| 109 | { |
| 110 | return EFI_SUCCESS; |
| 111 | } |
| 112 | |
| 113 | /* No loader configured, stub out EFI_ENTRY */ |
| 114 | static inline void efi_restore_gd(void) { } |
Simon Glass | 6e3c654 | 2021-07-02 12:36:16 -0600 | [diff] [blame] | 115 | static inline void efi_net_set_dhcp_ack(void *pkt, int len) { } |
| 116 | static inline void efi_print_image_infos(void *pc) { } |
| 117 | static inline efi_status_t efi_launch_capsules(void) |
| 118 | { |
| 119 | return EFI_SUCCESS; |
| 120 | } |
| 121 | |
| 122 | #endif /* CONFIG_IS_ENABLED(EFI_LOADER) */ |
Alexander Graf | cb149c6 | 2016-03-04 01:09:58 +0100 | [diff] [blame] | 123 | |
AKASHI Takahiro | 6422820 | 2024-01-17 13:39:41 +0900 | [diff] [blame] | 124 | #if CONFIG_IS_ENABLED(EFI_BINARY_EXEC) |
| 125 | /* Call this to unset the current device name */ |
| 126 | void efi_clear_bootdev(void); |
| 127 | /* Call this to set the current device name */ |
| 128 | void efi_set_bootdev(const char *dev, const char *devnr, const char *path, |
| 129 | void *buffer, size_t buffer_size); |
| 130 | #else |
| 131 | static inline void efi_clear_bootdev(void) { } |
| 132 | |
| 133 | static inline void efi_set_bootdev(const char *dev, const char *devnr, |
| 134 | const char *path, void *buffer, |
| 135 | size_t buffer_size) { } |
| 136 | #endif |
| 137 | |
Heinrich Schuchardt | 4182a12 | 2018-06-28 12:45:32 +0200 | [diff] [blame] | 138 | /* Maximum number of configuration tables */ |
| 139 | #define EFI_MAX_CONFIGURATION_TABLES 16 |
| 140 | |
Heinrich Schuchardt | 4e6b5d6 | 2018-09-20 21:58:23 +0200 | [diff] [blame] | 141 | /* GUID used by the root node */ |
| 142 | #define U_BOOT_GUID \ |
| 143 | EFI_GUID(0xe61d73b9, 0xa384, 0x4acc, \ |
| 144 | 0xae, 0xab, 0x82, 0xe8, 0x28, 0xf3, 0x62, 0x8b) |
Tobias Waldekranz | 272ec6b | 2023-02-16 16:33:55 +0100 | [diff] [blame] | 145 | /* GUID used as root for blkmap devices */ |
| 146 | #define U_BOOT_BLKMAP_DEV_GUID \ |
| 147 | EFI_GUID(0x4cad859d, 0xd644, 0x42ff, \ |
| 148 | 0x87, 0x0b, 0xc0, 0x2e, 0xac, 0x05, 0x58, 0x63) |
AKASHI Takahiro | 23ad52f | 2019-09-12 13:52:35 +0900 | [diff] [blame] | 149 | /* GUID used as host device on sandbox */ |
| 150 | #define U_BOOT_HOST_DEV_GUID \ |
| 151 | EFI_GUID(0xbbe4e671, 0x5773, 0x4ea1, \ |
| 152 | 0x9a, 0xab, 0x3a, 0x7d, 0xbf, 0x40, 0xc4, 0x82) |
Heinrich Schuchardt | 19ecced | 2020-05-20 22:39:35 +0200 | [diff] [blame] | 153 | /* GUID used as root for virtio devices */ |
| 154 | #define U_BOOT_VIRTIO_DEV_GUID \ |
| 155 | EFI_GUID(0x63293792, 0xadf5, 0x9325, \ |
| 156 | 0xb9, 0x9f, 0x4e, 0x0e, 0x45, 0x5c, 0x1b, 0x1e) |
Heinrich Schuchardt | 4e6b5d6 | 2018-09-20 21:58:23 +0200 | [diff] [blame] | 157 | |
Masahisa Kojima | 87d7914 | 2022-09-12 17:33:50 +0900 | [diff] [blame] | 158 | /* GUID for the auto generated boot menu entry */ |
| 159 | #define EFICONFIG_AUTO_GENERATED_ENTRY_GUID \ |
Masahisa Kojima | c1ab046 | 2023-10-12 14:31:59 +0900 | [diff] [blame] | 160 | EFI_GUID(0x8108ac4e, 0x9f11, 0x4d59, \ |
| 161 | 0x85, 0x0e, 0xe2, 0x1a, 0x52, 0x2c, 0x59, 0xb2) |
Masahisa Kojima | 87d7914 | 2022-09-12 17:33:50 +0900 | [diff] [blame] | 162 | |
Heinrich Schuchardt | 7a59725 | 2019-11-28 06:46:09 +0100 | [diff] [blame] | 163 | /* Use internal device tree when starting UEFI application */ |
Heinrich Schuchardt | f64f223 | 2019-12-08 01:07:01 +0100 | [diff] [blame] | 164 | #define EFI_FDT_USE_INTERNAL NULL |
Heinrich Schuchardt | 7a59725 | 2019-11-28 06:46:09 +0100 | [diff] [blame] | 165 | |
AKASHI Takahiro | a2a4bc3 | 2019-04-16 13:24:20 +0900 | [diff] [blame] | 166 | /* Root node */ |
| 167 | extern efi_handle_t efi_root; |
| 168 | |
Heinrich Schuchardt | 15b1bf1 | 2020-03-19 18:21:58 +0000 | [diff] [blame] | 169 | /* Set to EFI_SUCCESS when initialized */ |
| 170 | extern efi_status_t efi_obj_list_initialized; |
| 171 | |
Heinrich Schuchardt | fccd3d9 | 2020-11-12 21:26:28 +0100 | [diff] [blame] | 172 | /* Flag used by the selftest to avoid detaching devices in ExitBootServices() */ |
| 173 | extern bool efi_st_keep_devices; |
| 174 | |
Heinrich Schuchardt | 11078bb | 2020-03-19 15:16:31 +0100 | [diff] [blame] | 175 | /* EFI system partition */ |
| 176 | extern struct efi_system_partition { |
Simon Glass | 8149b15 | 2022-09-17 09:00:09 -0600 | [diff] [blame] | 177 | enum uclass_id uclass_id; |
Heinrich Schuchardt | 11078bb | 2020-03-19 15:16:31 +0100 | [diff] [blame] | 178 | int devnum; |
| 179 | u8 part; |
| 180 | } efi_system_partition; |
| 181 | |
Rob Clark | c160d2f | 2017-07-27 08:04:18 -0400 | [diff] [blame] | 182 | int __efi_entry_check(void); |
| 183 | int __efi_exit_check(void); |
Heinrich Schuchardt | ae0bd3a | 2017-08-18 17:45:16 +0200 | [diff] [blame] | 184 | const char *__efi_nesting(void); |
Rob Clark | af65db8 | 2017-07-27 08:04:19 -0400 | [diff] [blame] | 185 | const char *__efi_nesting_inc(void); |
| 186 | const char *__efi_nesting_dec(void); |
Rob Clark | c160d2f | 2017-07-27 08:04:18 -0400 | [diff] [blame] | 187 | |
Rob Clark | a095aad | 2017-07-27 08:04:17 -0400 | [diff] [blame] | 188 | /* |
| 189 | * Enter the u-boot world from UEFI: |
| 190 | */ |
Alexander Graf | bee9116 | 2016-03-04 01:09:59 +0100 | [diff] [blame] | 191 | #define EFI_ENTRY(format, ...) do { \ |
Rob Clark | c160d2f | 2017-07-27 08:04:18 -0400 | [diff] [blame] | 192 | assert(__efi_entry_check()); \ |
Rob Clark | af65db8 | 2017-07-27 08:04:19 -0400 | [diff] [blame] | 193 | debug("%sEFI: Entry %s(" format ")\n", __efi_nesting_inc(), \ |
| 194 | __func__, ##__VA_ARGS__); \ |
Alexander Graf | bee9116 | 2016-03-04 01:09:59 +0100 | [diff] [blame] | 195 | } while(0) |
Alexander Graf | bee9116 | 2016-03-04 01:09:59 +0100 | [diff] [blame] | 196 | |
Rob Clark | a095aad | 2017-07-27 08:04:17 -0400 | [diff] [blame] | 197 | /* |
| 198 | * Exit the u-boot world back to UEFI: |
| 199 | */ |
Rob Clark | 804b1d7 | 2017-07-24 10:31:52 -0400 | [diff] [blame] | 200 | #define EFI_EXIT(ret) ({ \ |
xypron.glpk@gmx.de | c81883d | 2017-08-17 18:57:36 +0200 | [diff] [blame] | 201 | typeof(ret) _r = ret; \ |
Rob Clark | af65db8 | 2017-07-27 08:04:19 -0400 | [diff] [blame] | 202 | debug("%sEFI: Exit: %s: %u\n", __efi_nesting_dec(), \ |
xypron.glpk@gmx.de | c81883d | 2017-08-17 18:57:36 +0200 | [diff] [blame] | 203 | __func__, (u32)((uintptr_t) _r & ~EFI_ERROR_MASK)); \ |
Rob Clark | c160d2f | 2017-07-27 08:04:18 -0400 | [diff] [blame] | 204 | assert(__efi_exit_check()); \ |
| 205 | _r; \ |
Rob Clark | 804b1d7 | 2017-07-24 10:31:52 -0400 | [diff] [blame] | 206 | }) |
Alexander Graf | bee9116 | 2016-03-04 01:09:59 +0100 | [diff] [blame] | 207 | |
Rob Clark | a095aad | 2017-07-27 08:04:17 -0400 | [diff] [blame] | 208 | /* |
Heinrich Schuchardt | ea630ce | 2017-09-15 10:06:10 +0200 | [diff] [blame] | 209 | * Call non-void UEFI function from u-boot and retrieve return value: |
Rob Clark | a095aad | 2017-07-27 08:04:17 -0400 | [diff] [blame] | 210 | */ |
Heinrich Schuchardt | ea630ce | 2017-09-15 10:06:10 +0200 | [diff] [blame] | 211 | #define EFI_CALL(exp) ({ \ |
| 212 | debug("%sEFI: Call: %s\n", __efi_nesting_inc(), #exp); \ |
| 213 | assert(__efi_exit_check()); \ |
| 214 | typeof(exp) _r = exp; \ |
| 215 | assert(__efi_entry_check()); \ |
| 216 | debug("%sEFI: %lu returned by %s\n", __efi_nesting_dec(), \ |
| 217 | (unsigned long)((uintptr_t)_r & ~EFI_ERROR_MASK), #exp); \ |
| 218 | _r; \ |
| 219 | }) |
| 220 | |
| 221 | /* |
| 222 | * Call void UEFI function from u-boot: |
| 223 | */ |
| 224 | #define EFI_CALL_VOID(exp) do { \ |
Rob Clark | af65db8 | 2017-07-27 08:04:19 -0400 | [diff] [blame] | 225 | debug("%sEFI: Call: %s\n", __efi_nesting_inc(), #exp); \ |
Rob Clark | c160d2f | 2017-07-27 08:04:18 -0400 | [diff] [blame] | 226 | assert(__efi_exit_check()); \ |
Rob Clark | a095aad | 2017-07-27 08:04:17 -0400 | [diff] [blame] | 227 | exp; \ |
Rob Clark | c160d2f | 2017-07-27 08:04:18 -0400 | [diff] [blame] | 228 | assert(__efi_entry_check()); \ |
Rob Clark | af65db8 | 2017-07-27 08:04:19 -0400 | [diff] [blame] | 229 | debug("%sEFI: Return From: %s\n", __efi_nesting_dec(), #exp); \ |
Rob Clark | a095aad | 2017-07-27 08:04:17 -0400 | [diff] [blame] | 230 | } while(0) |
| 231 | |
Heinrich Schuchardt | ae0bd3a | 2017-08-18 17:45:16 +0200 | [diff] [blame] | 232 | /* |
Heinrich Schuchardt | d550414 | 2018-01-11 08:16:01 +0100 | [diff] [blame] | 233 | * Write an indented message with EFI prefix |
Heinrich Schuchardt | ae0bd3a | 2017-08-18 17:45:16 +0200 | [diff] [blame] | 234 | */ |
Heinrich Schuchardt | d550414 | 2018-01-11 08:16:01 +0100 | [diff] [blame] | 235 | #define EFI_PRINT(format, ...) ({ \ |
| 236 | debug("%sEFI: " format, __efi_nesting(), \ |
| 237 | ##__VA_ARGS__); \ |
Heinrich Schuchardt | ae0bd3a | 2017-08-18 17:45:16 +0200 | [diff] [blame] | 238 | }) |
| 239 | |
Alexander Graf | 89aea43 | 2018-04-23 07:59:47 +0200 | [diff] [blame] | 240 | #ifdef CONFIG_SYS_CACHELINE_SIZE |
| 241 | #define EFI_CACHELINE_SIZE CONFIG_SYS_CACHELINE_SIZE |
| 242 | #else |
| 243 | /* Just use the greatest cache flush alignment requirement I'm aware of */ |
| 244 | #define EFI_CACHELINE_SIZE 128 |
| 245 | #endif |
| 246 | |
Masahisa Kojima | 87d7914 | 2022-09-12 17:33:50 +0900 | [diff] [blame] | 247 | /* max bootmenu title size for volume selection */ |
| 248 | #define BOOTMENU_DEVICE_NAME_MAX 16 |
| 249 | |
Heinrich Schuchardt | 1fcb7ea | 2018-07-02 12:53:55 +0200 | [diff] [blame] | 250 | /* Key identifying current memory map */ |
| 251 | extern efi_uintn_t efi_memory_map_key; |
| 252 | |
Alexander Graf | 50149ea | 2016-03-04 01:10:01 +0100 | [diff] [blame] | 253 | extern struct efi_runtime_services efi_runtime_services; |
Alexander Graf | bee9116 | 2016-03-04 01:09:59 +0100 | [diff] [blame] | 254 | extern struct efi_system_table systab; |
| 255 | |
Heinrich Schuchardt | ebb4dd5 | 2017-10-26 19:25:59 +0200 | [diff] [blame] | 256 | extern struct efi_simple_text_output_protocol efi_con_out; |
Heinrich Schuchardt | 3e603ec | 2018-09-08 10:20:10 +0200 | [diff] [blame] | 257 | extern struct efi_simple_text_input_protocol efi_con_in; |
Heinrich Schuchardt | ebb4dd5 | 2017-10-26 19:25:59 +0200 | [diff] [blame] | 258 | extern struct efi_console_control_protocol efi_console_control; |
xypron.glpk@gmx.de | cc5b708 | 2017-07-11 22:06:25 +0200 | [diff] [blame] | 259 | extern const struct efi_device_path_to_text_protocol efi_device_path_to_text; |
Leif Lindholm | e70f8df | 2018-03-09 17:43:21 +0100 | [diff] [blame] | 260 | /* implementation of the EFI_DEVICE_PATH_UTILITIES_PROTOCOL */ |
| 261 | extern const struct efi_device_path_utilities_protocol |
| 262 | efi_device_path_utilities; |
Heinrich Schuchardt | b1b782d | 2019-05-16 18:19:00 +0200 | [diff] [blame] | 263 | /* current version of the EFI_UNICODE_COLLATION_PROTOCOL */ |
Heinrich Schuchardt | 0bc4b0d | 2018-09-04 19:34:58 +0200 | [diff] [blame] | 264 | extern const struct efi_unicode_collation_protocol |
Heinrich Schuchardt | 95ab381 | 2019-05-16 07:52:58 +0200 | [diff] [blame] | 265 | efi_unicode_collation_protocol2; |
AKASHI Takahiro | cb728e5 | 2019-01-21 12:13:00 +0900 | [diff] [blame] | 266 | extern const struct efi_hii_config_routing_protocol efi_hii_config_routing; |
| 267 | extern const struct efi_hii_config_access_protocol efi_hii_config_access; |
Leif Lindholm | c9bfb22 | 2019-01-21 12:12:57 +0900 | [diff] [blame] | 268 | extern const struct efi_hii_database_protocol efi_hii_database; |
| 269 | extern const struct efi_hii_string_protocol efi_hii_string; |
Alexander Graf | c1311ad | 2016-03-04 01:10:00 +0100 | [diff] [blame] | 270 | |
Rob Clark | adae431 | 2017-09-13 18:05:30 -0400 | [diff] [blame] | 271 | uint16_t *efi_dp_str(struct efi_device_path *dp); |
| 272 | |
Masahisa Kojima | 87d7914 | 2022-09-12 17:33:50 +0900 | [diff] [blame] | 273 | /* GUID for the auto generated boot menu entry */ |
| 274 | extern const efi_guid_t efi_guid_bootmenu_auto_generated; |
| 275 | |
Heinrich Schuchardt | 4e6b5d6 | 2018-09-20 21:58:23 +0200 | [diff] [blame] | 276 | /* GUID of the U-Boot root node */ |
| 277 | extern const efi_guid_t efi_u_boot_guid; |
AKASHI Takahiro | 23ad52f | 2019-09-12 13:52:35 +0900 | [diff] [blame] | 278 | #ifdef CONFIG_SANDBOX |
| 279 | /* GUID of U-Boot host device on sandbox */ |
| 280 | extern const efi_guid_t efi_guid_host_dev; |
| 281 | #endif |
Heinrich Schuchardt | b3dd14b | 2018-01-19 20:24:45 +0100 | [diff] [blame] | 282 | /* GUID of the EFI_BLOCK_IO_PROTOCOL */ |
| 283 | extern const efi_guid_t efi_block_io_guid; |
Rob Clark | 9975fe9 | 2017-09-13 18:05:38 -0400 | [diff] [blame] | 284 | extern const efi_guid_t efi_global_variable_guid; |
Alexander Graf | c1311ad | 2016-03-04 01:10:00 +0100 | [diff] [blame] | 285 | extern const efi_guid_t efi_guid_console_control; |
Alexander Graf | cb149c6 | 2016-03-04 01:09:58 +0100 | [diff] [blame] | 286 | extern const efi_guid_t efi_guid_device_path; |
Heinrich Schuchardt | 90dcd9b | 2022-03-19 07:04:03 +0100 | [diff] [blame] | 287 | /* GUID of the EFI system partition */ |
| 288 | extern const efi_guid_t efi_system_partition_guid; |
Heinrich Schuchardt | f0959db | 2018-01-11 08:16:02 +0100 | [diff] [blame] | 289 | /* GUID of the EFI_DRIVER_BINDING_PROTOCOL */ |
| 290 | extern const efi_guid_t efi_guid_driver_binding_protocol; |
Heinrich Schuchardt | a3a28f5 | 2018-02-18 15:17:51 +0100 | [diff] [blame] | 291 | /* event group ExitBootServices() invoked */ |
| 292 | extern const efi_guid_t efi_guid_event_group_exit_boot_services; |
| 293 | /* event group SetVirtualAddressMap() invoked */ |
| 294 | extern const efi_guid_t efi_guid_event_group_virtual_address_change; |
| 295 | /* event group memory map changed */ |
| 296 | extern const efi_guid_t efi_guid_event_group_memory_map_change; |
| 297 | /* event group boot manager about to boot */ |
| 298 | extern const efi_guid_t efi_guid_event_group_ready_to_boot; |
| 299 | /* event group ResetSystem() invoked (before ExitBootServices) */ |
| 300 | extern const efi_guid_t efi_guid_event_group_reset_system; |
Masahisa Kojima | e0d1a1e | 2023-11-10 13:25:39 +0900 | [diff] [blame] | 301 | /* event group return to efibootmgr */ |
| 302 | extern const efi_guid_t efi_guid_event_group_return_to_efibootmgr; |
Heinrich Schuchardt | bc4f913 | 2018-03-03 15:29:03 +0100 | [diff] [blame] | 303 | /* GUID of the device tree table */ |
| 304 | extern const efi_guid_t efi_guid_fdt; |
Alexander Graf | cb149c6 | 2016-03-04 01:09:58 +0100 | [diff] [blame] | 305 | extern const efi_guid_t efi_guid_loaded_image; |
AKASHI Takahiro | bc8fc32 | 2019-03-27 13:40:32 +0900 | [diff] [blame] | 306 | extern const efi_guid_t efi_guid_loaded_image_device_path; |
xypron.glpk@gmx.de | cc5b708 | 2017-07-11 22:06:25 +0200 | [diff] [blame] | 307 | extern const efi_guid_t efi_guid_device_path_to_text_protocol; |
Rob Clark | 2a92080 | 2017-09-13 18:05:34 -0400 | [diff] [blame] | 308 | extern const efi_guid_t efi_simple_file_system_protocol_guid; |
| 309 | extern const efi_guid_t efi_file_info_guid; |
Heinrich Schuchardt | 9e6835e | 2018-04-04 15:42:11 +0200 | [diff] [blame] | 310 | /* GUID for file system information */ |
| 311 | extern const efi_guid_t efi_file_system_info_guid; |
Leif Lindholm | e70f8df | 2018-03-09 17:43:21 +0100 | [diff] [blame] | 312 | extern const efi_guid_t efi_guid_device_path_utilities_protocol; |
Heinrich Schuchardt | b1b782d | 2019-05-16 18:19:00 +0200 | [diff] [blame] | 313 | /* GUID of the deprecated Unicode collation protocol */ |
| 314 | extern const efi_guid_t efi_guid_unicode_collation_protocol; |
Heinrich Schuchardt | b6f1109 | 2020-12-04 03:33:41 +0100 | [diff] [blame] | 315 | /* GUIDs of the Load File and Load File2 protocol */ |
| 316 | extern const efi_guid_t efi_guid_load_file_protocol; |
| 317 | extern const efi_guid_t efi_guid_load_file2_protocol; |
Heinrich Schuchardt | 0bc4b0d | 2018-09-04 19:34:58 +0200 | [diff] [blame] | 318 | /* GUID of the Unicode collation protocol */ |
Heinrich Schuchardt | 95ab381 | 2019-05-16 07:52:58 +0200 | [diff] [blame] | 319 | extern const efi_guid_t efi_guid_unicode_collation_protocol2; |
AKASHI Takahiro | cb728e5 | 2019-01-21 12:13:00 +0900 | [diff] [blame] | 320 | extern const efi_guid_t efi_guid_hii_config_routing_protocol; |
| 321 | extern const efi_guid_t efi_guid_hii_config_access_protocol; |
Leif Lindholm | c9bfb22 | 2019-01-21 12:12:57 +0900 | [diff] [blame] | 322 | extern const efi_guid_t efi_guid_hii_database_protocol; |
| 323 | extern const efi_guid_t efi_guid_hii_string_protocol; |
AKASHI Takahiro | 593e17d | 2020-04-14 11:51:39 +0900 | [diff] [blame] | 324 | /* GUIDs for authentication */ |
| 325 | extern const efi_guid_t efi_guid_image_security_database; |
| 326 | extern const efi_guid_t efi_guid_sha256; |
| 327 | extern const efi_guid_t efi_guid_cert_x509; |
| 328 | extern const efi_guid_t efi_guid_cert_x509_sha256; |
Ilias Apalodimas | b436cc6 | 2022-05-06 15:36:00 +0300 | [diff] [blame] | 329 | extern const efi_guid_t efi_guid_cert_x509_sha384; |
| 330 | extern const efi_guid_t efi_guid_cert_x509_sha512; |
AKASHI Takahiro | 767f6ee | 2020-04-14 11:51:41 +0900 | [diff] [blame] | 331 | extern const efi_guid_t efi_guid_cert_type_pkcs7; |
Alexander Graf | cb149c6 | 2016-03-04 01:09:58 +0100 | [diff] [blame] | 332 | |
Sughosh Ganu | 33c37d9 | 2019-12-29 00:01:06 +0530 | [diff] [blame] | 333 | /* GUID of RNG protocol */ |
| 334 | extern const efi_guid_t efi_guid_rng_protocol; |
AKASHI Takahiro | 2bc27ca | 2020-11-17 09:27:55 +0900 | [diff] [blame] | 335 | /* GUID of capsule update result */ |
| 336 | extern const efi_guid_t efi_guid_capsule_report; |
AKASHI Takahiro | 8d99026 | 2020-11-30 18:12:11 +0900 | [diff] [blame] | 337 | /* GUID of firmware management protocol */ |
| 338 | extern const efi_guid_t efi_guid_firmware_management_protocol; |
Jose Marinho | 64a8aae | 2021-03-02 17:26:38 +0000 | [diff] [blame] | 339 | /* GUID for the ESRT */ |
| 340 | extern const efi_guid_t efi_esrt_guid; |
Masahisa Kojima | 3d49ee8 | 2021-10-26 17:27:24 +0900 | [diff] [blame] | 341 | /* GUID of the SMBIOS table */ |
| 342 | extern const efi_guid_t smbios_guid; |
Masahisa Kojima | 2497f6a | 2024-01-26 09:53:42 +0900 | [diff] [blame] | 343 | extern const efi_guid_t smbios3_guid; |
Masahisa Kojima | 87d7914 | 2022-09-12 17:33:50 +0900 | [diff] [blame] | 344 | /*GUID of console */ |
| 345 | extern const efi_guid_t efi_guid_text_input_protocol; |
Masahisa Kojima | 8dbd0a0 | 2023-01-24 15:56:15 +0900 | [diff] [blame] | 346 | extern const efi_guid_t efi_guid_text_output_protocol; |
Sughosh Ganu | 33c37d9 | 2019-12-29 00:01:06 +0530 | [diff] [blame] | 347 | |
Marek Behún | 2bdc6f5 | 2021-05-20 13:23:56 +0200 | [diff] [blame] | 348 | extern char __efi_runtime_start[], __efi_runtime_stop[]; |
| 349 | extern char __efi_runtime_rel_start[], __efi_runtime_rel_stop[]; |
Alexander Graf | 50149ea | 2016-03-04 01:10:01 +0100 | [diff] [blame] | 350 | |
Heinrich Schuchardt | 1f1075c | 2019-05-21 17:51:35 +0200 | [diff] [blame] | 351 | /** |
| 352 | * struct efi_open_protocol_info_item - open protocol info item |
| 353 | * |
Heinrich Schuchardt | fe1599d | 2018-01-11 08:15:57 +0100 | [diff] [blame] | 354 | * When a protocol is opened a open protocol info entry is created. |
| 355 | * These are maintained in a list. |
Heinrich Schuchardt | 1f1075c | 2019-05-21 17:51:35 +0200 | [diff] [blame] | 356 | * |
| 357 | * @link: link to the list of open protocol info entries of a protocol |
| 358 | * @info: information about the opening of a protocol |
Heinrich Schuchardt | fe1599d | 2018-01-11 08:15:57 +0100 | [diff] [blame] | 359 | */ |
| 360 | struct efi_open_protocol_info_item { |
Heinrich Schuchardt | fe1599d | 2018-01-11 08:15:57 +0100 | [diff] [blame] | 361 | struct list_head link; |
| 362 | struct efi_open_protocol_info_entry info; |
| 363 | }; |
| 364 | |
Heinrich Schuchardt | 1f1075c | 2019-05-21 17:51:35 +0200 | [diff] [blame] | 365 | /** |
| 366 | * struct efi_handler - single protocol interface of a handle |
| 367 | * |
Alexander Graf | bee9116 | 2016-03-04 01:09:59 +0100 | [diff] [blame] | 368 | * When the UEFI payload wants to open a protocol on an object to get its |
| 369 | * interface (usually a struct with callback functions), this struct maps the |
Heinrich Schuchardt | fe1599d | 2018-01-11 08:15:57 +0100 | [diff] [blame] | 370 | * protocol GUID to the respective protocol interface |
Heinrich Schuchardt | 1f1075c | 2019-05-21 17:51:35 +0200 | [diff] [blame] | 371 | * |
| 372 | * @link: link to the list of protocols of a handle |
| 373 | * @guid: GUID of the protocol |
| 374 | * @protocol_interface: protocol interface |
Heinrich Schuchardt | c6f077a | 2021-02-25 08:02:37 +0100 | [diff] [blame] | 375 | * @open_infos: link to the list of open protocol info items |
Heinrich Schuchardt | fe1599d | 2018-01-11 08:15:57 +0100 | [diff] [blame] | 376 | */ |
Alexander Graf | bee9116 | 2016-03-04 01:09:59 +0100 | [diff] [blame] | 377 | struct efi_handler { |
Heinrich Schuchardt | 69fb6b1 | 2017-11-26 14:05:17 +0100 | [diff] [blame] | 378 | struct list_head link; |
Heinrich Schuchardt | 6602893 | 2022-03-09 19:56:23 +0100 | [diff] [blame] | 379 | const efi_guid_t guid; |
xypron.glpk@gmx.de | b5349f7 | 2017-07-11 22:06:14 +0200 | [diff] [blame] | 380 | void *protocol_interface; |
Heinrich Schuchardt | fe1599d | 2018-01-11 08:15:57 +0100 | [diff] [blame] | 381 | struct list_head open_infos; |
Alexander Graf | bee9116 | 2016-03-04 01:09:59 +0100 | [diff] [blame] | 382 | }; |
| 383 | |
Heinrich Schuchardt | fae0118 | 2018-09-26 05:27:55 +0200 | [diff] [blame] | 384 | /** |
Heinrich Schuchardt | cd73aba | 2019-05-01 14:20:18 +0200 | [diff] [blame] | 385 | * enum efi_object_type - type of EFI object |
| 386 | * |
| 387 | * In UnloadImage we must be able to identify if the handle relates to a |
| 388 | * started image. |
| 389 | */ |
| 390 | enum efi_object_type { |
Heinrich Schuchardt | c6f077a | 2021-02-25 08:02:37 +0100 | [diff] [blame] | 391 | /** @EFI_OBJECT_TYPE_UNDEFINED: undefined image type */ |
Heinrich Schuchardt | cd73aba | 2019-05-01 14:20:18 +0200 | [diff] [blame] | 392 | EFI_OBJECT_TYPE_UNDEFINED = 0, |
Heinrich Schuchardt | c6f077a | 2021-02-25 08:02:37 +0100 | [diff] [blame] | 393 | /** @EFI_OBJECT_TYPE_U_BOOT_FIRMWARE: U-Boot firmware */ |
Heinrich Schuchardt | 84a918e | 2019-05-05 16:55:06 +0200 | [diff] [blame] | 394 | EFI_OBJECT_TYPE_U_BOOT_FIRMWARE, |
Heinrich Schuchardt | c6f077a | 2021-02-25 08:02:37 +0100 | [diff] [blame] | 395 | /** @EFI_OBJECT_TYPE_LOADED_IMAGE: loaded image (not started) */ |
Heinrich Schuchardt | cd73aba | 2019-05-01 14:20:18 +0200 | [diff] [blame] | 396 | EFI_OBJECT_TYPE_LOADED_IMAGE, |
Heinrich Schuchardt | c6f077a | 2021-02-25 08:02:37 +0100 | [diff] [blame] | 397 | /** @EFI_OBJECT_TYPE_STARTED_IMAGE: started image */ |
Heinrich Schuchardt | cd73aba | 2019-05-01 14:20:18 +0200 | [diff] [blame] | 398 | EFI_OBJECT_TYPE_STARTED_IMAGE, |
| 399 | }; |
| 400 | |
| 401 | /** |
Heinrich Schuchardt | fae0118 | 2018-09-26 05:27:55 +0200 | [diff] [blame] | 402 | * struct efi_object - dereferenced EFI handle |
Alexander Graf | bee9116 | 2016-03-04 01:09:59 +0100 | [diff] [blame] | 403 | * |
Heinrich Schuchardt | fae0118 | 2018-09-26 05:27:55 +0200 | [diff] [blame] | 404 | * @link: pointers to put the handle into a linked list |
| 405 | * @protocols: linked list with the protocol interfaces installed on this |
| 406 | * handle |
Heinrich Schuchardt | c6f077a | 2021-02-25 08:02:37 +0100 | [diff] [blame] | 407 | * @type: image type if the handle relates to an image |
Masahisa Kojima | ee57666 | 2022-07-22 11:39:10 +0900 | [diff] [blame] | 408 | * @dev: pointer to the DM device which is associated with this EFI handle |
Heinrich Schuchardt | fae0118 | 2018-09-26 05:27:55 +0200 | [diff] [blame] | 409 | * |
| 410 | * UEFI offers a flexible and expandable object model. The objects in the UEFI |
| 411 | * API are devices, drivers, and loaded images. struct efi_object is our storage |
| 412 | * structure for these objects. |
| 413 | * |
| 414 | * When including this structure into a larger structure always put it first so |
| 415 | * that when deleting a handle the whole encompassing structure can be freed. |
| 416 | * |
| 417 | * A pointer to this structure is referred to as a handle. Typedef efi_handle_t |
| 418 | * has been created for such pointers. |
Alexander Graf | bee9116 | 2016-03-04 01:09:59 +0100 | [diff] [blame] | 419 | */ |
| 420 | struct efi_object { |
| 421 | /* Every UEFI object is part of a global object list */ |
| 422 | struct list_head link; |
Heinrich Schuchardt | 69fb6b1 | 2017-11-26 14:05:17 +0100 | [diff] [blame] | 423 | /* The list of protocols */ |
| 424 | struct list_head protocols; |
Heinrich Schuchardt | cd73aba | 2019-05-01 14:20:18 +0200 | [diff] [blame] | 425 | enum efi_object_type type; |
Masahisa Kojima | ee57666 | 2022-07-22 11:39:10 +0900 | [diff] [blame] | 426 | struct udevice *dev; |
Alexander Graf | bee9116 | 2016-03-04 01:09:59 +0100 | [diff] [blame] | 427 | }; |
| 428 | |
AKASHI Takahiro | 4540dab | 2020-04-14 11:51:44 +0900 | [diff] [blame] | 429 | enum efi_image_auth_status { |
| 430 | EFI_IMAGE_AUTH_FAILED = 0, |
| 431 | EFI_IMAGE_AUTH_PASSED, |
| 432 | }; |
| 433 | |
xypron.glpk@gmx.de | c684159 | 2017-07-18 20:17:18 +0200 | [diff] [blame] | 434 | /** |
Heinrich Schuchardt | c982874 | 2018-09-23 17:21:51 +0200 | [diff] [blame] | 435 | * struct efi_loaded_image_obj - handle of a loaded image |
Heinrich Schuchardt | d39646a | 2018-09-26 05:27:56 +0200 | [diff] [blame] | 436 | * |
| 437 | * @header: EFI object header |
Heinrich Schuchardt | 556d8dc | 2019-04-30 17:57:30 +0200 | [diff] [blame] | 438 | * @exit_status: exit status passed to Exit() |
| 439 | * @exit_data_size: exit data size passed to Exit() |
| 440 | * @exit_data: exit data passed to Exit() |
Heinrich Schuchardt | 0ce3fb5 | 2020-12-28 22:42:51 +0100 | [diff] [blame] | 441 | * @exit_jmp: long jump buffer for returning from started image |
Heinrich Schuchardt | d39646a | 2018-09-26 05:27:56 +0200 | [diff] [blame] | 442 | * @entry: entry address of the relocated image |
Heinrich Schuchardt | 0ce3fb5 | 2020-12-28 22:42:51 +0100 | [diff] [blame] | 443 | * @image_type: indicates if the image is an applicition or a driver |
| 444 | * @auth_status: indicates if the image is authenticated |
Heinrich Schuchardt | c982874 | 2018-09-23 17:21:51 +0200 | [diff] [blame] | 445 | */ |
| 446 | struct efi_loaded_image_obj { |
Heinrich Schuchardt | d39646a | 2018-09-26 05:27:56 +0200 | [diff] [blame] | 447 | struct efi_object header; |
Heinrich Schuchardt | f8212f0 | 2020-12-28 23:24:40 +0100 | [diff] [blame] | 448 | efi_status_t *exit_status; |
Heinrich Schuchardt | 556d8dc | 2019-04-30 17:57:30 +0200 | [diff] [blame] | 449 | efi_uintn_t *exit_data_size; |
| 450 | u16 **exit_data; |
Heinrich Schuchardt | f8212f0 | 2020-12-28 23:24:40 +0100 | [diff] [blame] | 451 | struct jmp_buf_data *exit_jmp; |
Heinrich Schuchardt | c982874 | 2018-09-23 17:21:51 +0200 | [diff] [blame] | 452 | EFIAPI efi_status_t (*entry)(efi_handle_t image_handle, |
| 453 | struct efi_system_table *st); |
Heinrich Schuchardt | 126a43f | 2019-05-01 20:07:04 +0200 | [diff] [blame] | 454 | u16 image_type; |
AKASHI Takahiro | 4540dab | 2020-04-14 11:51:44 +0900 | [diff] [blame] | 455 | enum efi_image_auth_status auth_status; |
Heinrich Schuchardt | c982874 | 2018-09-23 17:21:51 +0200 | [diff] [blame] | 456 | }; |
| 457 | |
| 458 | /** |
xypron.glpk@gmx.de | c684159 | 2017-07-18 20:17:18 +0200 | [diff] [blame] | 459 | * struct efi_event |
| 460 | * |
Heinrich Schuchardt | 43bce44 | 2018-02-18 15:17:50 +0100 | [diff] [blame] | 461 | * @link: Link to list of all events |
Heinrich Schuchardt | 7a69e97 | 2019-06-05 21:00:39 +0200 | [diff] [blame] | 462 | * @queue_link: Link to the list of queued events |
xypron.glpk@gmx.de | c684159 | 2017-07-18 20:17:18 +0200 | [diff] [blame] | 463 | * @type: Type of event, see efi_create_event |
| 464 | * @notify_tpl: Task priority level of notifications |
Heinrich Schuchardt | c6f077a | 2021-02-25 08:02:37 +0100 | [diff] [blame] | 465 | * @notify_function: Function to call when the event is triggered |
xypron.glpk@gmx.de | c684159 | 2017-07-18 20:17:18 +0200 | [diff] [blame] | 466 | * @notify_context: Data to be passed to the notify function |
Heinrich Schuchardt | b095f3c | 2018-02-18 15:17:52 +0100 | [diff] [blame] | 467 | * @group: Event group |
Heinrich Schuchardt | 43bce44 | 2018-02-18 15:17:50 +0100 | [diff] [blame] | 468 | * @trigger_time: Period of the timer |
| 469 | * @trigger_next: Next time to trigger the timer |
xypron.glpk@gmx.de | c684159 | 2017-07-18 20:17:18 +0200 | [diff] [blame] | 470 | * @trigger_type: Type of timer, see efi_set_timer |
Heinrich Schuchardt | 43bce44 | 2018-02-18 15:17:50 +0100 | [diff] [blame] | 471 | * @is_signaled: The event occurred. The event is in the signaled state. |
xypron.glpk@gmx.de | c684159 | 2017-07-18 20:17:18 +0200 | [diff] [blame] | 472 | */ |
| 473 | struct efi_event { |
Heinrich Schuchardt | 43bce44 | 2018-02-18 15:17:50 +0100 | [diff] [blame] | 474 | struct list_head link; |
Heinrich Schuchardt | 7a69e97 | 2019-06-05 21:00:39 +0200 | [diff] [blame] | 475 | struct list_head queue_link; |
xypron.glpk@gmx.de | b521d29 | 2017-07-19 19:22:34 +0200 | [diff] [blame] | 476 | uint32_t type; |
Heinrich Schuchardt | 152cade | 2017-11-06 21:17:47 +0100 | [diff] [blame] | 477 | efi_uintn_t notify_tpl; |
xypron.glpk@gmx.de | c684159 | 2017-07-18 20:17:18 +0200 | [diff] [blame] | 478 | void (EFIAPI *notify_function)(struct efi_event *event, void *context); |
| 479 | void *notify_context; |
Heinrich Schuchardt | b095f3c | 2018-02-18 15:17:52 +0100 | [diff] [blame] | 480 | const efi_guid_t *group; |
xypron.glpk@gmx.de | c684159 | 2017-07-18 20:17:18 +0200 | [diff] [blame] | 481 | u64 trigger_next; |
| 482 | u64 trigger_time; |
xypron.glpk@gmx.de | b521d29 | 2017-07-19 19:22:34 +0200 | [diff] [blame] | 483 | enum efi_timer_delay trigger_type; |
Heinrich Schuchardt | e190e89 | 2017-10-04 15:03:24 +0200 | [diff] [blame] | 484 | bool is_signaled; |
xypron.glpk@gmx.de | c684159 | 2017-07-18 20:17:18 +0200 | [diff] [blame] | 485 | }; |
| 486 | |
Alexander Graf | bee9116 | 2016-03-04 01:09:59 +0100 | [diff] [blame] | 487 | /* This list contains all UEFI objects we know of */ |
| 488 | extern struct list_head efi_obj_list; |
Heinrich Schuchardt | b095f3c | 2018-02-18 15:17:52 +0100 | [diff] [blame] | 489 | /* List of all events */ |
| 490 | extern struct list_head efi_events; |
Alexander Graf | bee9116 | 2016-03-04 01:09:59 +0100 | [diff] [blame] | 491 | |
Heinrich Schuchardt | ab15d41 | 2019-05-04 17:27:54 +0200 | [diff] [blame] | 492 | /** |
Heinrich Schuchardt | f09cea3 | 2019-05-21 18:19:01 +0200 | [diff] [blame] | 493 | * struct efi_protocol_notification - handle for notified protocol |
| 494 | * |
| 495 | * When a protocol interface is installed for which an event was registered with |
| 496 | * the RegisterProtocolNotify() service this structure is used to hold the |
| 497 | * handle on which the protocol interface was installed. |
| 498 | * |
| 499 | * @link: link to list of all handles notified for this event |
| 500 | * @handle: handle on which the notified protocol interface was installed |
| 501 | */ |
| 502 | struct efi_protocol_notification { |
| 503 | struct list_head link; |
| 504 | efi_handle_t handle; |
| 505 | }; |
| 506 | |
| 507 | /** |
Heinrich Schuchardt | c6f077a | 2021-02-25 08:02:37 +0100 | [diff] [blame] | 508 | * struct efi_register_notify_event - event registered by |
| 509 | * RegisterProtocolNotify() |
Heinrich Schuchardt | ab15d41 | 2019-05-04 17:27:54 +0200 | [diff] [blame] | 510 | * |
| 511 | * The address of this structure serves as registration value. |
| 512 | * |
Heinrich Schuchardt | f09cea3 | 2019-05-21 18:19:01 +0200 | [diff] [blame] | 513 | * @link: link to list of all registered events |
| 514 | * @event: registered event. The same event may registered for multiple |
| 515 | * GUIDs. |
| 516 | * @protocol: protocol for which the event is registered |
| 517 | * @handles: linked list of all handles on which the notified protocol was |
| 518 | * installed |
Heinrich Schuchardt | ab15d41 | 2019-05-04 17:27:54 +0200 | [diff] [blame] | 519 | */ |
| 520 | struct efi_register_notify_event { |
| 521 | struct list_head link; |
| 522 | struct efi_event *event; |
| 523 | efi_guid_t protocol; |
Heinrich Schuchardt | f09cea3 | 2019-05-21 18:19:01 +0200 | [diff] [blame] | 524 | struct list_head handles; |
Heinrich Schuchardt | ab15d41 | 2019-05-04 17:27:54 +0200 | [diff] [blame] | 525 | }; |
| 526 | |
AKASHI Takahiro | a57ad20 | 2022-04-19 10:05:11 +0900 | [diff] [blame] | 527 | /* called at pre-initialization */ |
| 528 | int efi_init_early(void); |
AKASHI Takahiro | 056b45b | 2018-12-30 15:16:55 +0100 | [diff] [blame] | 529 | /* Initialize efi execution environment */ |
| 530 | efi_status_t efi_init_obj_list(void); |
Raymond Mao | 339b527 | 2023-06-19 14:22:58 -0700 | [diff] [blame] | 531 | /* Append new boot option in BootOrder variable */ |
| 532 | efi_status_t efi_bootmgr_append_bootorder(u16 index); |
| 533 | /* Get unused "Boot####" index */ |
| 534 | efi_status_t efi_bootmgr_get_unused_bootoption(u16 *buf, |
| 535 | efi_uintn_t buf_size, u32 *index); |
| 536 | /* Generate the media device boot option */ |
| 537 | efi_status_t efi_bootmgr_update_media_device_boot_option(void); |
| 538 | /* Delete selected boot option */ |
| 539 | efi_status_t efi_bootmgr_delete_boot_option(u16 boot_index); |
AKASHI Takahiro | 0bef4b0 | 2023-11-21 10:29:44 +0900 | [diff] [blame] | 540 | /* Invoke EFI boot manager */ |
| 541 | efi_status_t efi_bootmgr_run(void *fdt); |
Raymond Mao | 339b527 | 2023-06-19 14:22:58 -0700 | [diff] [blame] | 542 | /* search the boot option index in BootOrder */ |
| 543 | bool efi_search_bootorder(u16 *bootorder, efi_uintn_t num, u32 target, u32 *index); |
Heinrich Schuchardt | 68edbed | 2022-06-14 08:02:03 +0200 | [diff] [blame] | 544 | /* Set up console modes */ |
| 545 | void efi_setup_console_size(void); |
AKASHI Takahiro | 0bef4b0 | 2023-11-21 10:29:44 +0900 | [diff] [blame] | 546 | /* Set up load options from environment variable */ |
| 547 | efi_status_t efi_env_set_load_options(efi_handle_t handle, const char *env_var, |
| 548 | u16 **load_options); |
Heinrich Schuchardt | fa07721 | 2024-01-26 08:54:30 +0100 | [diff] [blame] | 549 | /* Get EFI configuration table */ |
| 550 | void *efi_get_configuration_table(const efi_guid_t *guid); |
Heinrich Schuchardt | f64f223 | 2019-12-08 01:07:01 +0100 | [diff] [blame] | 551 | /* Install device tree */ |
| 552 | efi_status_t efi_install_fdt(void *fdt); |
AKASHI Takahiro | 6422820 | 2024-01-17 13:39:41 +0900 | [diff] [blame] | 553 | /* Execute loaded UEFI image */ |
| 554 | efi_status_t do_bootefi_exec(efi_handle_t handle, void *load_options); |
AKASHI Takahiro | 0bef4b0 | 2023-11-21 10:29:44 +0900 | [diff] [blame] | 555 | /* Run loaded UEFI image with given fdt */ |
| 556 | efi_status_t efi_binary_run(void *image, size_t size, void *fdt); |
Heinrich Schuchardt | 8819209 | 2019-06-20 13:52:16 +0200 | [diff] [blame] | 557 | /* Initialize variable services */ |
| 558 | efi_status_t efi_init_variables(void); |
Heinrich Schuchardt | 29018ab | 2019-06-20 15:25:48 +0200 | [diff] [blame] | 559 | /* Notify ExitBootServices() is called */ |
| 560 | void efi_variables_boot_exit_notify(void); |
Masahisa Kojima | fdff03e | 2021-08-13 16:12:41 +0900 | [diff] [blame] | 561 | efi_status_t efi_tcg2_notify_exit_boot_services_failed(void); |
Masahisa Kojima | 8fc4e0b | 2021-08-13 16:12:40 +0900 | [diff] [blame] | 562 | /* Measure efi application invocation */ |
Masahisa Kojima | ce3dbc5 | 2021-10-26 17:27:25 +0900 | [diff] [blame] | 563 | efi_status_t efi_tcg2_measure_efi_app_invocation(struct efi_loaded_image_obj *handle); |
Masahisa Kojima | 8fc4e0b | 2021-08-13 16:12:40 +0900 | [diff] [blame] | 564 | /* Measure efi application exit */ |
| 565 | efi_status_t efi_tcg2_measure_efi_app_exit(void); |
Etienne Carriere | aa2d394 | 2023-02-16 17:29:48 +0100 | [diff] [blame] | 566 | /* Measure DTB */ |
| 567 | efi_status_t efi_tcg2_measure_dtb(void *dtb); |
Heinrich Schuchardt | 4e6b5d6 | 2018-09-20 21:58:23 +0200 | [diff] [blame] | 568 | /* Called by bootefi to initialize root node */ |
| 569 | efi_status_t efi_root_node_register(void); |
Heinrich Schuchardt | 640adad | 2018-06-28 12:45:31 +0200 | [diff] [blame] | 570 | /* Called by bootefi to initialize runtime */ |
| 571 | efi_status_t efi_initialize_system_table(void); |
Heinrich Schuchardt | 7f95104 | 2019-07-05 17:42:16 +0200 | [diff] [blame] | 572 | /* efi_runtime_detach() - detach unimplemented runtime functions */ |
| 573 | void efi_runtime_detach(void); |
Heinrich Schuchardt | a44d2a2 | 2020-03-24 18:05:22 +0100 | [diff] [blame] | 574 | /* efi_convert_pointer() - convert pointer to virtual address */ |
| 575 | efi_status_t EFIAPI efi_convert_pointer(efi_uintn_t debug_disposition, |
| 576 | void **address); |
Heinrich Schuchardt | 94686f6 | 2020-12-13 10:30:24 +0100 | [diff] [blame] | 577 | /* Carve out DT reserved memory ranges */ |
| 578 | void efi_carve_out_dt_rsv(void *fdt); |
Ilias Apalodimas | a2f1482 | 2022-01-03 14:07:37 +0200 | [diff] [blame] | 579 | /* Purge unused kaslr-seed */ |
| 580 | void efi_try_purge_kaslr_seed(void *fdt); |
xypron.glpk@gmx.de | 91be9a7 | 2017-07-18 20:17:22 +0200 | [diff] [blame] | 581 | /* Called by bootefi to make console interface available */ |
Heinrich Schuchardt | 6f566c2 | 2018-10-02 06:08:26 +0200 | [diff] [blame] | 582 | efi_status_t efi_console_register(void); |
Heinrich Schuchardt | d5391bf | 2022-08-31 16:37:35 +0200 | [diff] [blame] | 583 | /* Called by efi_init_obj_list() to proble all block devices */ |
| 584 | efi_status_t efi_disks_register(void); |
Heinrich Schuchardt | b59c13d | 2020-09-25 12:50:19 +0200 | [diff] [blame] | 585 | /* Called by efi_init_obj_list() to install EFI_RNG_PROTOCOL */ |
| 586 | efi_status_t efi_rng_register(void); |
Ilias Apalodimas | c1c0210 | 2020-11-11 11:18:11 +0200 | [diff] [blame] | 587 | /* Called by efi_init_obj_list() to install EFI_TCG2_PROTOCOL */ |
| 588 | efi_status_t efi_tcg2_register(void); |
Sunil V L | 1ccf871 | 2022-01-28 20:48:44 +0530 | [diff] [blame] | 589 | /* Called by efi_init_obj_list() to install RISCV_EFI_BOOT_PROTOCOL */ |
| 590 | efi_status_t efi_riscv_register(void); |
Masahisa Kojima | 54bec17 | 2021-12-07 14:15:31 +0900 | [diff] [blame] | 591 | /* Called by efi_init_obj_list() to do initial measurement */ |
| 592 | efi_status_t efi_tcg2_do_initial_measurement(void); |
Masahisa Kojima | 163a0d7 | 2021-05-26 12:09:58 +0900 | [diff] [blame] | 593 | /* measure the pe-coff image, extend PCR and add Event Log */ |
| 594 | efi_status_t tcg2_measure_pe_image(void *efi, u64 efi_size, |
| 595 | struct efi_loaded_image_obj *handle, |
| 596 | struct efi_loaded_image *loaded_image_info); |
Heinrich Schuchardt | 64e4db0 | 2018-01-19 20:24:47 +0100 | [diff] [blame] | 597 | /* Create handles and protocols for the partitions of a block device */ |
| 598 | int efi_disk_create_partitions(efi_handle_t parent, struct blk_desc *desc, |
Simon Glass | 8149b15 | 2022-09-17 09:00:09 -0600 | [diff] [blame] | 599 | const char *uclass_idname, int diskid, |
Heinrich Schuchardt | 64e4db0 | 2018-01-19 20:24:47 +0100 | [diff] [blame] | 600 | const char *pdevname); |
Alexander Graf | be8d324 | 2016-03-15 18:38:21 +0100 | [diff] [blame] | 601 | /* Called by bootefi to make GOP (graphical) interface available */ |
Heinrich Schuchardt | 80ea9b0 | 2018-03-03 15:28:55 +0100 | [diff] [blame] | 602 | efi_status_t efi_gop_register(void); |
Alexander Graf | 0efe1bc | 2016-05-06 21:01:01 +0200 | [diff] [blame] | 603 | /* Called by bootefi to make the network interface available */ |
Heinrich Schuchardt | 075d425 | 2018-03-03 15:28:56 +0100 | [diff] [blame] | 604 | efi_status_t efi_net_register(void); |
Heinrich Schuchardt | b3d6090 | 2017-10-18 18:13:04 +0200 | [diff] [blame] | 605 | /* Called by bootefi to make the watchdog available */ |
Heinrich Schuchardt | d7b181d | 2018-03-03 15:28:57 +0100 | [diff] [blame] | 606 | efi_status_t efi_watchdog_register(void); |
Ilias Apalodimas | ec80b47 | 2020-02-21 09:55:45 +0200 | [diff] [blame] | 607 | efi_status_t efi_initrd_register(void); |
Ilias Apalodimas | 70089c1 | 2022-10-16 11:36:32 +0300 | [diff] [blame] | 608 | efi_status_t efi_initrd_deregister(void); |
Alexander Graf | e663b35 | 2016-08-19 01:23:29 +0200 | [diff] [blame] | 609 | /* Called by bootefi to make SMBIOS tables available */ |
Simon Glass | 0864c56 | 2018-05-16 09:42:19 -0600 | [diff] [blame] | 610 | /** |
Bin Meng | 86df34d | 2018-06-27 20:38:03 -0700 | [diff] [blame] | 611 | * efi_acpi_register() - write out ACPI tables |
| 612 | * |
| 613 | * Called by bootefi to make ACPI tables available |
| 614 | * |
Heinrich Schuchardt | 185f812 | 2022-01-19 18:05:50 +0100 | [diff] [blame] | 615 | * Return: 0 if OK, -ENOMEM if no memory is available for the tables |
Bin Meng | 86df34d | 2018-06-27 20:38:03 -0700 | [diff] [blame] | 616 | */ |
| 617 | efi_status_t efi_acpi_register(void); |
| 618 | /** |
Simon Glass | 0864c56 | 2018-05-16 09:42:19 -0600 | [diff] [blame] | 619 | * efi_smbios_register() - write out SMBIOS tables |
| 620 | * |
| 621 | * Called by bootefi to make SMBIOS tables available |
| 622 | * |
Heinrich Schuchardt | 185f812 | 2022-01-19 18:05:50 +0100 | [diff] [blame] | 623 | * Return: 0 if OK, -ENOMEM if no memory is available for the tables |
Simon Glass | 0864c56 | 2018-05-16 09:42:19 -0600 | [diff] [blame] | 624 | */ |
Heinrich Schuchardt | 7657152 | 2018-03-03 15:28:54 +0100 | [diff] [blame] | 625 | efi_status_t efi_smbios_register(void); |
Alexander Graf | 0efe1bc | 2016-05-06 21:01:01 +0200 | [diff] [blame] | 626 | |
Rob Clark | 2a92080 | 2017-09-13 18:05:34 -0400 | [diff] [blame] | 627 | struct efi_simple_file_system_protocol * |
| 628 | efi_fs_from_path(struct efi_device_path *fp); |
| 629 | |
Heinrich Schuchardt | b3d6090 | 2017-10-18 18:13:04 +0200 | [diff] [blame] | 630 | /* Called by efi_set_watchdog_timer to reset the timer */ |
| 631 | efi_status_t efi_set_watchdog(unsigned long timeout); |
Alexander Graf | 0efe1bc | 2016-05-06 21:01:01 +0200 | [diff] [blame] | 632 | |
Alexander Graf | bee9116 | 2016-03-04 01:09:59 +0100 | [diff] [blame] | 633 | /* Called from places to check whether a timer expired */ |
| 634 | void efi_timer_check(void); |
Heinrich Schuchardt | 5dad05a | 2021-01-12 12:40:32 +0100 | [diff] [blame] | 635 | /* Check if a buffer contains a PE-COFF image */ |
| 636 | efi_status_t efi_check_pe(void *buffer, size_t size, void **nt_header); |
Alexander Graf | bee9116 | 2016-03-04 01:09:59 +0100 | [diff] [blame] | 637 | /* PE loader implementation */ |
AKASHI Takahiro | 4540dab | 2020-04-14 11:51:44 +0900 | [diff] [blame] | 638 | efi_status_t efi_load_pe(struct efi_loaded_image_obj *handle, |
| 639 | void *efi, size_t efi_size, |
Heinrich Schuchardt | 8f7e2b2 | 2018-12-26 12:49:09 +0100 | [diff] [blame] | 640 | struct efi_loaded_image *loaded_image_info); |
Alexander Graf | bee9116 | 2016-03-04 01:09:59 +0100 | [diff] [blame] | 641 | /* Called once to store the pristine gd pointer */ |
| 642 | void efi_save_gd(void); |
Alexander Graf | 50149ea | 2016-03-04 01:10:01 +0100 | [diff] [blame] | 643 | /* Call this to relocate the runtime section to an address space */ |
| 644 | void efi_runtime_relocate(ulong offset, struct efi_mem_desc *map); |
Rui Miguel Silva | bfef72e | 2022-05-11 10:55:40 +0100 | [diff] [blame] | 645 | /* Call this to get image parameters */ |
| 646 | void efi_get_image_parameters(void **img_addr, size_t *img_size); |
Heinrich Schuchardt | 44549d6 | 2017-11-26 14:05:23 +0100 | [diff] [blame] | 647 | /* Add a new object to the object list. */ |
Heinrich Schuchardt | fae0118 | 2018-09-26 05:27:55 +0200 | [diff] [blame] | 648 | void efi_add_handle(efi_handle_t obj); |
Heinrich Schuchardt | 2edab5e | 2017-10-26 19:25:49 +0200 | [diff] [blame] | 649 | /* Create handle */ |
Heinrich Schuchardt | 2074f70 | 2018-01-11 08:16:09 +0100 | [diff] [blame] | 650 | efi_status_t efi_create_handle(efi_handle_t *handle); |
Heinrich Schuchardt | 678e03a | 2017-12-04 18:03:02 +0100 | [diff] [blame] | 651 | /* Delete handle */ |
Ilias Apalodimas | 54edc37 | 2023-07-24 13:17:36 +0300 | [diff] [blame] | 652 | efi_status_t efi_delete_handle(efi_handle_t obj); |
Heinrich Schuchardt | 1b68153 | 2017-11-06 21:17:50 +0100 | [diff] [blame] | 653 | /* Call this to validate a handle and find the EFI object for it */ |
Heinrich Schuchardt | 2074f70 | 2018-01-11 08:16:09 +0100 | [diff] [blame] | 654 | struct efi_object *efi_search_obj(const efi_handle_t handle); |
AKASHI Takahiro | d8465ff | 2022-04-28 17:09:38 +0900 | [diff] [blame] | 655 | /* Locate device_path handle */ |
| 656 | efi_status_t EFIAPI efi_locate_device_path(const efi_guid_t *protocol, |
| 657 | struct efi_device_path **device_path, |
| 658 | efi_handle_t *device); |
AKASHI Takahiro | d7e0b01 | 2019-03-05 14:53:31 +0900 | [diff] [blame] | 659 | /* Load image */ |
| 660 | efi_status_t EFIAPI efi_load_image(bool boot_policy, |
| 661 | efi_handle_t parent_image, |
| 662 | struct efi_device_path *file_path, |
| 663 | void *source_buffer, |
| 664 | efi_uintn_t source_size, |
| 665 | efi_handle_t *image_handle); |
Heinrich Schuchardt | f69d63f | 2018-12-26 13:28:09 +0100 | [diff] [blame] | 666 | /* Start image */ |
| 667 | efi_status_t EFIAPI efi_start_image(efi_handle_t image_handle, |
| 668 | efi_uintn_t *exit_data_size, |
| 669 | u16 **exit_data); |
AKASHI Takahiro | d7e0b01 | 2019-03-05 14:53:31 +0900 | [diff] [blame] | 670 | /* Unload image */ |
| 671 | efi_status_t EFIAPI efi_unload_image(efi_handle_t image_handle); |
Heinrich Schuchardt | 3f79a2b | 2017-10-26 19:25:53 +0200 | [diff] [blame] | 672 | /* Find a protocol on a handle */ |
Heinrich Schuchardt | 2074f70 | 2018-01-11 08:16:09 +0100 | [diff] [blame] | 673 | efi_status_t efi_search_protocol(const efi_handle_t handle, |
Heinrich Schuchardt | 3f79a2b | 2017-10-26 19:25:53 +0200 | [diff] [blame] | 674 | const efi_guid_t *protocol_guid, |
| 675 | struct efi_handler **handler); |
| 676 | /* Install new protocol on a handle */ |
Heinrich Schuchardt | 2074f70 | 2018-01-11 08:16:09 +0100 | [diff] [blame] | 677 | efi_status_t efi_add_protocol(const efi_handle_t handle, |
| 678 | const efi_guid_t *protocol, |
Heinrich Schuchardt | 3f79a2b | 2017-10-26 19:25:53 +0200 | [diff] [blame] | 679 | void *protocol_interface); |
Heinrich Schuchardt | f9ad240 | 2020-01-10 12:33:59 +0100 | [diff] [blame] | 680 | /* Open protocol */ |
| 681 | efi_status_t efi_protocol_open(struct efi_handler *handler, |
| 682 | void **protocol_interface, void *agent_handle, |
| 683 | void *controller_handle, uint32_t attributes); |
| 684 | |
Heinrich Schuchardt | 7657ae1 | 2019-04-12 06:59:49 +0200 | [diff] [blame] | 685 | /* Install multiple protocol interfaces */ |
Ilias Apalodimas | 05c4c9e | 2022-10-06 16:08:46 +0300 | [diff] [blame] | 686 | efi_status_t EFIAPI |
| 687 | efi_install_multiple_protocol_interfaces(efi_handle_t *handle, ...); |
| 688 | efi_status_t EFIAPI |
| 689 | efi_uninstall_multiple_protocol_interfaces(efi_handle_t handle, ...); |
AKASHI Takahiro | b51ec63 | 2020-03-17 11:12:36 +0900 | [diff] [blame] | 690 | /* Get handles that support a given protocol */ |
| 691 | efi_status_t EFIAPI efi_locate_handle_buffer( |
| 692 | enum efi_locate_search_type search_type, |
| 693 | const efi_guid_t *protocol, void *search_key, |
| 694 | efi_uintn_t *no_handles, efi_handle_t **buffer); |
Heinrich Schuchardt | ef18576 | 2022-10-07 15:18:15 +0200 | [diff] [blame] | 695 | /* Close a previously opened protocol interface */ |
| 696 | efi_status_t efi_close_protocol(efi_handle_t handle, const efi_guid_t *protocol, |
| 697 | efi_handle_t agent_handle, |
| 698 | efi_handle_t controller_handle); |
AKASHI Takahiro | b51ec63 | 2020-03-17 11:12:36 +0900 | [diff] [blame] | 699 | /* Open a protocol interface */ |
| 700 | efi_status_t EFIAPI efi_handle_protocol(efi_handle_t handle, |
| 701 | const efi_guid_t *protocol, |
| 702 | void **protocol_interface); |
xypron.glpk@gmx.de | 49deb45 | 2017-07-18 20:17:20 +0200 | [diff] [blame] | 703 | /* Call this to create an event */ |
Heinrich Schuchardt | 152cade | 2017-11-06 21:17:47 +0100 | [diff] [blame] | 704 | efi_status_t efi_create_event(uint32_t type, efi_uintn_t notify_tpl, |
xypron.glpk@gmx.de | 49deb45 | 2017-07-18 20:17:20 +0200 | [diff] [blame] | 705 | void (EFIAPI *notify_function) ( |
| 706 | struct efi_event *event, |
| 707 | void *context), |
Masahisa Kojima | e23c8e8 | 2023-11-10 13:25:38 +0900 | [diff] [blame] | 708 | void *notify_context, const efi_guid_t *group, |
Heinrich Schuchardt | b095f3c | 2018-02-18 15:17:52 +0100 | [diff] [blame] | 709 | struct efi_event **event); |
xypron.glpk@gmx.de | bfc7246 | 2017-07-18 20:17:21 +0200 | [diff] [blame] | 710 | /* Call this to set a timer */ |
xypron.glpk@gmx.de | b521d29 | 2017-07-19 19:22:34 +0200 | [diff] [blame] | 711 | efi_status_t efi_set_timer(struct efi_event *event, enum efi_timer_delay type, |
xypron.glpk@gmx.de | bfc7246 | 2017-07-18 20:17:21 +0200 | [diff] [blame] | 712 | uint64_t trigger_time); |
xypron.glpk@gmx.de | 91be9a7 | 2017-07-18 20:17:22 +0200 | [diff] [blame] | 713 | /* Call this to signal an event */ |
Heinrich Schuchardt | 7eaa900 | 2019-06-07 06:47:01 +0200 | [diff] [blame] | 714 | void efi_signal_event(struct efi_event *event); |
Alexander Graf | 50149ea | 2016-03-04 01:10:01 +0100 | [diff] [blame] | 715 | |
AKASHI Takahiro | 05f391e | 2022-05-12 11:29:01 +0900 | [diff] [blame] | 716 | /* return true if the device is removable */ |
| 717 | bool efi_disk_is_removable(efi_handle_t handle); |
| 718 | |
Heinrich Schuchardt | cff7700 | 2023-07-30 14:03:53 +0200 | [diff] [blame] | 719 | /** |
| 720 | * efi_create_simple_file_system() - create simple file system protocol |
| 721 | * |
| 722 | * Create a simple file system protocol for a partition. |
| 723 | * |
| 724 | * @desc: block device descriptor |
| 725 | * @part: partition number |
| 726 | * @dp: device path |
| 727 | * @fsp: simple file system protocol |
| 728 | * Return: status code |
| 729 | */ |
| 730 | efi_status_t |
| 731 | efi_create_simple_file_system(struct blk_desc *desc, int part, |
| 732 | struct efi_device_path *dp, |
| 733 | struct efi_simple_file_system_protocol **fsp); |
Rob Clark | 2a92080 | 2017-09-13 18:05:34 -0400 | [diff] [blame] | 734 | |
| 735 | /* open file from device-path: */ |
| 736 | struct efi_file_handle *efi_file_from_path(struct efi_device_path *fp); |
| 737 | |
Jose Marinho | 64a8aae | 2021-03-02 17:26:38 +0000 | [diff] [blame] | 738 | /* Registers a callback function for a notification event. */ |
| 739 | efi_status_t EFIAPI efi_register_protocol_notify(const efi_guid_t *protocol, |
| 740 | struct efi_event *event, |
| 741 | void **registration); |
Ilias Apalodimas | 37c3ca5 | 2021-03-17 21:54:59 +0200 | [diff] [blame] | 742 | efi_status_t efi_file_size(struct efi_file_handle *fh, efi_uintn_t *size); |
| 743 | |
| 744 | /* get a device path from a Boot#### option */ |
| 745 | struct efi_device_path *efi_get_dp_from_boot(const efi_guid_t guid); |
| 746 | |
Ilias Apalodimas | b436cc6 | 2022-05-06 15:36:00 +0300 | [diff] [blame] | 747 | /* get len, string (used in u-boot crypto from a guid */ |
| 748 | const char *guid_to_sha_str(const efi_guid_t *guid); |
| 749 | int algo_to_len(const char *algo); |
| 750 | |
Masahisa Kojima | ee57666 | 2022-07-22 11:39:10 +0900 | [diff] [blame] | 751 | int efi_link_dev(efi_handle_t handle, struct udevice *dev); |
Heinrich Schuchardt | 16b27b6 | 2022-10-03 09:47:51 +0200 | [diff] [blame] | 752 | int efi_unlink_dev(efi_handle_t handle); |
Masahisa Kojima | 3ac026a | 2022-12-02 13:59:35 +0900 | [diff] [blame] | 753 | bool efi_varname_is_load_option(u16 *var_name16, int *index); |
Masahisa Kojima | ce32708 | 2022-12-19 11:33:12 +0900 | [diff] [blame] | 754 | efi_status_t efi_next_variable_name(efi_uintn_t *size, u16 **buf, |
| 755 | efi_guid_t *guid); |
Masahisa Kojima | ee57666 | 2022-07-22 11:39:10 +0900 | [diff] [blame] | 756 | |
Heinrich Schuchardt | c3772ca | 2018-11-18 17:58:49 +0100 | [diff] [blame] | 757 | /** |
| 758 | * efi_size_in_pages() - convert size in bytes to size in pages |
| 759 | * |
| 760 | * This macro returns the number of EFI memory pages required to hold 'size' |
| 761 | * bytes. |
| 762 | * |
| 763 | * @size: size in bytes |
| 764 | * Return: size in pages |
| 765 | */ |
Heinrich Schuchardt | 0a7e516 | 2021-01-17 07:52:09 +0100 | [diff] [blame] | 766 | #define efi_size_in_pages(size) (((size) + EFI_PAGE_MASK) >> EFI_PAGE_SHIFT) |
Heinrich Schuchardt | f606fab | 2023-03-19 09:20:22 +0100 | [diff] [blame] | 767 | /* Allocate boot service data pool memory */ |
| 768 | void *efi_alloc(size_t len); |
Ilias Apalodimas | ebdea88 | 2021-10-11 15:10:23 +0300 | [diff] [blame] | 769 | /* Allocate pages on the specified alignment */ |
| 770 | void *efi_alloc_aligned_pages(u64 len, int memory_type, size_t align); |
Alexander Graf | 5d00995 | 2016-03-04 01:10:04 +0100 | [diff] [blame] | 771 | /* More specific EFI memory allocator, called by EFI payloads */ |
Heinrich Schuchardt | 49d225e | 2021-08-17 15:05:31 +0200 | [diff] [blame] | 772 | efi_status_t efi_allocate_pages(enum efi_allocate_type type, |
| 773 | enum efi_memory_type memory_type, |
| 774 | efi_uintn_t pages, uint64_t *memory); |
Stefan Brüns | b61d857 | 2016-10-01 23:32:27 +0200 | [diff] [blame] | 775 | /* EFI memory free function. */ |
Heinrich Schuchardt | f5a2a93 | 2017-11-06 21:17:48 +0100 | [diff] [blame] | 776 | efi_status_t efi_free_pages(uint64_t memory, efi_uintn_t pages); |
Stefan Brüns | ead1274 | 2016-10-09 22:17:18 +0200 | [diff] [blame] | 777 | /* EFI memory allocator for small allocations */ |
Heinrich Schuchardt | 49d225e | 2021-08-17 15:05:31 +0200 | [diff] [blame] | 778 | efi_status_t efi_allocate_pool(enum efi_memory_type pool_type, |
| 779 | efi_uintn_t size, void **buffer); |
Stefan Brüns | 42417bc | 2016-10-09 22:17:26 +0200 | [diff] [blame] | 780 | /* EFI pool memory free function. */ |
| 781 | efi_status_t efi_free_pool(void *buffer); |
Heinrich Schuchardt | eff4440 | 2023-01-05 18:26:01 +0100 | [diff] [blame] | 782 | /* Allocate and retrieve EFI memory map */ |
| 783 | efi_status_t efi_get_memory_map_alloc(efi_uintn_t *map_size, |
| 784 | struct efi_mem_desc **memory_map); |
Alexander Graf | 5d00995 | 2016-03-04 01:10:04 +0100 | [diff] [blame] | 785 | /* Returns the EFI memory map */ |
Heinrich Schuchardt | f5a2a93 | 2017-11-06 21:17:48 +0100 | [diff] [blame] | 786 | efi_status_t efi_get_memory_map(efi_uintn_t *memory_map_size, |
Alexander Graf | 5d00995 | 2016-03-04 01:10:04 +0100 | [diff] [blame] | 787 | struct efi_mem_desc *memory_map, |
Heinrich Schuchardt | f5a2a93 | 2017-11-06 21:17:48 +0100 | [diff] [blame] | 788 | efi_uintn_t *map_key, |
| 789 | efi_uintn_t *descriptor_size, |
Alexander Graf | 5d00995 | 2016-03-04 01:10:04 +0100 | [diff] [blame] | 790 | uint32_t *descriptor_version); |
| 791 | /* Adds a range into the EFI memory map */ |
Michael Walle | 714497e | 2020-05-17 12:29:19 +0200 | [diff] [blame] | 792 | efi_status_t efi_add_memory_map(u64 start, u64 size, int memory_type); |
Park, Aiden | b5b9eff | 2019-09-03 17:43:43 +0000 | [diff] [blame] | 793 | /* Adds a conventional range into the EFI memory map */ |
| 794 | efi_status_t efi_add_conventional_memory_map(u64 ram_start, u64 ram_end, |
| 795 | u64 ram_top); |
| 796 | |
Heinrich Schuchardt | 05ef48a | 2018-01-21 19:29:30 +0100 | [diff] [blame] | 797 | /* Called by board init to initialize the EFI drivers */ |
Heinrich Schuchardt | 038782a | 2018-02-01 12:53:32 +0100 | [diff] [blame] | 798 | efi_status_t efi_driver_init(void); |
Heinrich Schuchardt | f05911a | 2022-10-06 07:29:41 +0200 | [diff] [blame] | 799 | /* Called when a block device is added */ |
| 800 | int efi_disk_probe(void *ctx, struct event *event); |
| 801 | /* Called when a block device is removed */ |
| 802 | int efi_disk_remove(void *ctx, struct event *event); |
Alexander Graf | 5d00995 | 2016-03-04 01:10:04 +0100 | [diff] [blame] | 803 | /* Called by board init to initialize the EFI memory map */ |
| 804 | int efi_memory_init(void); |
Alexander Graf | 488bf12 | 2016-08-19 01:23:24 +0200 | [diff] [blame] | 805 | /* Adds new or overrides configuration table entry to the system table */ |
| 806 | efi_status_t efi_install_configuration_table(const efi_guid_t *guid, void *table); |
Heinrich Schuchardt | 56d9288 | 2017-12-04 18:03:01 +0100 | [diff] [blame] | 807 | /* Sets up a loaded image */ |
Heinrich Schuchardt | c982874 | 2018-09-23 17:21:51 +0200 | [diff] [blame] | 808 | efi_status_t efi_setup_loaded_image(struct efi_device_path *device_path, |
| 809 | struct efi_device_path *file_path, |
| 810 | struct efi_loaded_image_obj **handle_ptr, |
| 811 | struct efi_loaded_image **info_ptr); |
Alexander Graf | 5d00995 | 2016-03-04 01:10:04 +0100 | [diff] [blame] | 812 | |
Alexander Graf | 51735ae | 2016-05-11 18:25:48 +0200 | [diff] [blame] | 813 | #ifdef CONFIG_EFI_LOADER_BOUNCE_BUFFER |
| 814 | extern void *efi_bounce_buffer; |
| 815 | #define EFI_LOADER_BOUNCE_BUFFER_SIZE (64 * 1024 * 1024) |
| 816 | #endif |
| 817 | |
Heinrich Schuchardt | 8399488 | 2022-02-26 12:10:10 +0100 | [diff] [blame] | 818 | /* shorten device path */ |
| 819 | struct efi_device_path *efi_dp_shorten(struct efi_device_path *dp); |
Rob Clark | b66c60d | 2017-09-13 18:05:28 -0400 | [diff] [blame] | 820 | struct efi_device_path *efi_dp_next(const struct efi_device_path *dp); |
Heinrich Schuchardt | ff401d3 | 2017-10-26 19:25:48 +0200 | [diff] [blame] | 821 | int efi_dp_match(const struct efi_device_path *a, |
| 822 | const struct efi_device_path *b); |
Heinrich Schuchardt | c409593 | 2022-03-04 08:20:00 +0100 | [diff] [blame] | 823 | efi_handle_t efi_dp_find_obj(struct efi_device_path *dp, |
Heinrich Schuchardt | e46ef1d | 2022-03-19 06:35:43 +0100 | [diff] [blame] | 824 | const efi_guid_t *guid, |
Heinrich Schuchardt | c409593 | 2022-03-04 08:20:00 +0100 | [diff] [blame] | 825 | struct efi_device_path **rem); |
Heinrich Schuchardt | f6dd3f3 | 2018-04-16 07:59:08 +0200 | [diff] [blame] | 826 | /* get size of the first device path instance excluding end node */ |
| 827 | efi_uintn_t efi_dp_instance_size(const struct efi_device_path *dp); |
| 828 | /* size of multi-instance device path excluding end node */ |
| 829 | efi_uintn_t efi_dp_size(const struct efi_device_path *dp); |
Rob Clark | b66c60d | 2017-09-13 18:05:28 -0400 | [diff] [blame] | 830 | struct efi_device_path *efi_dp_dup(const struct efi_device_path *dp); |
Rob Clark | b66c60d | 2017-09-13 18:05:28 -0400 | [diff] [blame] | 831 | struct efi_device_path *efi_dp_append_node(const struct efi_device_path *dp, |
| 832 | const struct efi_device_path *node); |
Heinrich Schuchardt | 211314c | 2018-04-16 07:59:05 +0200 | [diff] [blame] | 833 | /* Create a device path node of given type, sub-type, length */ |
| 834 | struct efi_device_path *efi_dp_create_device_node(const u8 type, |
| 835 | const u8 sub_type, |
| 836 | const u16 length); |
Heinrich Schuchardt | 3acef5d | 2018-04-16 07:59:09 +0200 | [diff] [blame] | 837 | /* Append device path instance */ |
| 838 | struct efi_device_path *efi_dp_append_instance( |
| 839 | const struct efi_device_path *dp, |
| 840 | const struct efi_device_path *dpi); |
| 841 | /* Get next device path instance */ |
| 842 | struct efi_device_path *efi_dp_get_next_instance(struct efi_device_path **dp, |
| 843 | efi_uintn_t *size); |
| 844 | /* Check if a device path contains muliple instances */ |
| 845 | bool efi_dp_is_multi_instance(const struct efi_device_path *dp); |
Rob Clark | b66c60d | 2017-09-13 18:05:28 -0400 | [diff] [blame] | 846 | |
Rob Clark | b66c60d | 2017-09-13 18:05:28 -0400 | [diff] [blame] | 847 | struct efi_device_path *efi_dp_from_part(struct blk_desc *desc, int part); |
Heinrich Schuchardt | 98d48bd | 2018-01-19 20:24:46 +0100 | [diff] [blame] | 848 | /* Create a device node for a block device partition. */ |
| 849 | struct efi_device_path *efi_dp_part_node(struct blk_desc *desc, int part); |
Heinrich Schuchardt | c7c0ca3 | 2023-05-13 10:36:21 +0200 | [diff] [blame] | 850 | struct efi_device_path *efi_dp_from_file(const struct efi_device_path *dp, |
Rob Clark | b66c60d | 2017-09-13 18:05:28 -0400 | [diff] [blame] | 851 | const char *path); |
| 852 | struct efi_device_path *efi_dp_from_eth(void); |
Rob Clark | bf19273 | 2017-10-10 08:23:06 -0400 | [diff] [blame] | 853 | struct efi_device_path *efi_dp_from_mem(uint32_t mem_type, |
| 854 | uint64_t start_address, |
| 855 | uint64_t end_address); |
Heinrich Schuchardt | 65436f9 | 2018-01-19 20:24:49 +0100 | [diff] [blame] | 856 | /* Determine the last device path node that is not the end node. */ |
| 857 | const struct efi_device_path *efi_dp_last_node( |
| 858 | const struct efi_device_path *dp); |
Heinrich Schuchardt | 0429868 | 2018-01-19 20:24:37 +0100 | [diff] [blame] | 859 | efi_status_t efi_dp_split_file_path(struct efi_device_path *full_path, |
| 860 | struct efi_device_path **device_path, |
| 861 | struct efi_device_path **file_path); |
Heinrich Schuchardt | 3c95b32 | 2022-02-04 20:47:09 +0100 | [diff] [blame] | 862 | struct efi_device_path *efi_dp_from_uart(void); |
AKASHI Takahiro | f1589ff | 2018-10-17 16:32:03 +0900 | [diff] [blame] | 863 | efi_status_t efi_dp_from_name(const char *dev, const char *devnr, |
| 864 | const char *path, |
| 865 | struct efi_device_path **device, |
| 866 | struct efi_device_path **file); |
Heinrich Schuchardt | 5cad4a3 | 2020-08-23 10:49:46 +0200 | [diff] [blame] | 867 | ssize_t efi_dp_check_length(const struct efi_device_path *dp, |
| 868 | const size_t maxlen); |
Rob Clark | b66c60d | 2017-09-13 18:05:28 -0400 | [diff] [blame] | 869 | |
| 870 | #define EFI_DP_TYPE(_dp, _type, _subtype) \ |
| 871 | (((_dp)->type == DEVICE_PATH_TYPE_##_type) && \ |
| 872 | ((_dp)->sub_type == DEVICE_PATH_SUB_TYPE_##_subtype)) |
| 873 | |
Masahisa Kojima | 9897350 | 2022-06-19 13:55:59 +0900 | [diff] [blame] | 874 | /* template END node: */ |
| 875 | extern const struct efi_device_path END; |
| 876 | |
AKASHI Takahiro | e771b4b | 2019-06-05 13:21:38 +0900 | [diff] [blame] | 877 | /* Indicate supported runtime services */ |
| 878 | efi_status_t efi_init_runtime_supported(void); |
| 879 | |
Heinrich Schuchardt | a39f39c | 2018-07-29 09:49:04 +0200 | [diff] [blame] | 880 | /* Update CRC32 in table header */ |
| 881 | void __efi_runtime efi_update_table_header_crc32(struct efi_table_hdr *table); |
| 882 | |
Alexander Graf | 80a4800 | 2016-08-16 21:08:45 +0200 | [diff] [blame] | 883 | /* Boards may provide the functions below to implement RTS functionality */ |
| 884 | |
Alexander Graf | 3c63db9 | 2016-10-14 13:45:30 +0200 | [diff] [blame] | 885 | void __efi_runtime EFIAPI efi_reset_system( |
Alexander Graf | 80a4800 | 2016-08-16 21:08:45 +0200 | [diff] [blame] | 886 | enum efi_reset_type reset_type, |
| 887 | efi_status_t reset_status, |
| 888 | unsigned long data_size, void *reset_data); |
Heinrich Schuchardt | 22c793e | 2018-03-03 15:28:59 +0100 | [diff] [blame] | 889 | |
| 890 | /* Architecture specific initialization of the EFI subsystem */ |
| 891 | efi_status_t efi_reset_system_init(void); |
Alexander Graf | 80a4800 | 2016-08-16 21:08:45 +0200 | [diff] [blame] | 892 | |
Alexander Graf | 3c63db9 | 2016-10-14 13:45:30 +0200 | [diff] [blame] | 893 | efi_status_t __efi_runtime EFIAPI efi_get_time( |
Alexander Graf | 80a4800 | 2016-08-16 21:08:45 +0200 | [diff] [blame] | 894 | struct efi_time *time, |
| 895 | struct efi_time_cap *capabilities); |
Alexander Graf | 80a4800 | 2016-08-16 21:08:45 +0200 | [diff] [blame] | 896 | |
Heinrich Schuchardt | 656f171 | 2019-05-31 07:38:29 +0200 | [diff] [blame] | 897 | efi_status_t __efi_runtime EFIAPI efi_set_time(struct efi_time *time); |
| 898 | |
Heinrich Schuchardt | 623b3a5 | 2017-09-15 10:06:11 +0200 | [diff] [blame] | 899 | /* |
| 900 | * Entry point for the tests of the EFI API. |
| 901 | * It is called by 'bootefi selftest' |
| 902 | */ |
| 903 | efi_status_t EFIAPI efi_selftest(efi_handle_t image_handle, |
| 904 | struct efi_system_table *systab); |
Heinrich Schuchardt | 623b3a5 | 2017-09-15 10:06:11 +0200 | [diff] [blame] | 905 | |
Heinrich Schuchardt | 0bda81b | 2018-12-30 20:53:51 +0100 | [diff] [blame] | 906 | efi_status_t EFIAPI efi_get_variable(u16 *variable_name, |
| 907 | const efi_guid_t *vendor, u32 *attributes, |
| 908 | efi_uintn_t *data_size, void *data); |
Heinrich Schuchardt | 45c66f9 | 2018-05-17 07:57:05 +0200 | [diff] [blame] | 909 | efi_status_t EFIAPI efi_get_next_variable_name(efi_uintn_t *variable_name_size, |
| 910 | u16 *variable_name, |
Heinrich Schuchardt | 7a4e717 | 2020-03-22 18:28:20 +0100 | [diff] [blame] | 911 | efi_guid_t *vendor); |
Heinrich Schuchardt | 0bda81b | 2018-12-30 20:53:51 +0100 | [diff] [blame] | 912 | efi_status_t EFIAPI efi_set_variable(u16 *variable_name, |
| 913 | const efi_guid_t *vendor, u32 attributes, |
Heinrich Schuchardt | 452257a | 2018-12-30 21:03:15 +0100 | [diff] [blame] | 914 | efi_uintn_t data_size, const void *data); |
Rob Clark | ad644e7 | 2017-09-13 18:05:37 -0400 | [diff] [blame] | 915 | |
Heinrich Schuchardt | ce43528 | 2019-06-20 12:13:05 +0200 | [diff] [blame] | 916 | efi_status_t EFIAPI efi_query_variable_info( |
| 917 | u32 attributes, u64 *maximum_variable_storage_size, |
| 918 | u64 *remaining_variable_storage_size, |
| 919 | u64 *maximum_variable_size); |
| 920 | |
Heinrich Schuchardt | d47671c | 2021-09-09 07:12:14 +0200 | [diff] [blame] | 921 | void *efi_get_var(const u16 *name, const efi_guid_t *vendor, efi_uintn_t *size); |
Ilias Apalodimas | 37c3ca5 | 2021-03-17 21:54:59 +0200 | [diff] [blame] | 922 | |
AKASHI Takahiro | 1a82b34 | 2018-11-05 18:06:41 +0900 | [diff] [blame] | 923 | /* |
| 924 | * See section 3.1.3 in the v2.7 UEFI spec for more details on |
| 925 | * the layout of EFI_LOAD_OPTION. In short it is: |
| 926 | * |
| 927 | * typedef struct _EFI_LOAD_OPTION { |
| 928 | * UINT32 Attributes; |
| 929 | * UINT16 FilePathListLength; |
| 930 | * // CHAR16 Description[]; <-- variable length, NULL terminated |
| 931 | * // EFI_DEVICE_PATH_PROTOCOL FilePathList[]; |
| 932 | * <-- FilePathListLength bytes |
| 933 | * // UINT8 OptionalData[]; |
| 934 | * } EFI_LOAD_OPTION; |
| 935 | */ |
| 936 | struct efi_load_option { |
| 937 | u32 attributes; |
| 938 | u16 file_path_length; |
| 939 | u16 *label; |
| 940 | struct efi_device_path *file_path; |
Heinrich Schuchardt | 39a1ff8 | 2019-04-29 13:51:45 +0200 | [diff] [blame] | 941 | const u8 *optional_data; |
AKASHI Takahiro | 1a82b34 | 2018-11-05 18:06:41 +0900 | [diff] [blame] | 942 | }; |
| 943 | |
Ilias Apalodimas | 76e8acc | 2021-03-17 21:54:58 +0200 | [diff] [blame] | 944 | struct efi_device_path *efi_dp_from_lo(struct efi_load_option *lo, |
Heinrich Schuchardt | 0421735 | 2021-10-15 01:31:02 +0200 | [diff] [blame] | 945 | const efi_guid_t *guid); |
Ilias Apalodimas | 76e8acc | 2021-03-17 21:54:58 +0200 | [diff] [blame] | 946 | struct efi_device_path *efi_dp_concat(const struct efi_device_path *dp1, |
Ilias Apalodimas | f19171c | 2024-01-08 10:55:33 +0200 | [diff] [blame] | 947 | const struct efi_device_path *dp2, |
| 948 | bool split_end_node); |
Masahisa Kojima | ce3dbc5 | 2021-10-26 17:27:25 +0900 | [diff] [blame] | 949 | struct efi_device_path *search_gpt_dp_node(struct efi_device_path *device_path); |
Heinrich Schuchardt | 0e69bcf | 2020-05-31 22:46:09 +0200 | [diff] [blame] | 950 | efi_status_t efi_deserialize_load_option(struct efi_load_option *lo, u8 *data, |
| 951 | efi_uintn_t *size); |
AKASHI Takahiro | 1a82b34 | 2018-11-05 18:06:41 +0900 | [diff] [blame] | 952 | unsigned long efi_serialize_load_option(struct efi_load_option *lo, u8 **data); |
Heinrich Schuchardt | 1064d04 | 2020-08-07 17:47:13 +0200 | [diff] [blame] | 953 | efi_status_t efi_set_load_options(efi_handle_t handle, |
| 954 | efi_uintn_t load_options_size, |
| 955 | void *load_options); |
Heinrich Schuchardt | 0ad6400 | 2020-08-07 17:49:39 +0200 | [diff] [blame] | 956 | efi_status_t efi_bootmgr_load(efi_handle_t *handle, void **load_options); |
Rob Clark | 9975fe9 | 2017-09-13 18:05:38 -0400 | [diff] [blame] | 957 | |
AKASHI Takahiro | 593e17d | 2020-04-14 11:51:39 +0900 | [diff] [blame] | 958 | /** |
Heinrich Schuchardt | c6f077a | 2021-02-25 08:02:37 +0100 | [diff] [blame] | 959 | * struct efi_image_regions - A list of memory regions |
AKASHI Takahiro | 593e17d | 2020-04-14 11:51:39 +0900 | [diff] [blame] | 960 | * |
| 961 | * @max: Maximum number of regions |
| 962 | * @num: Number of regions |
| 963 | * @reg: array of regions |
| 964 | */ |
| 965 | struct efi_image_regions { |
| 966 | int max; |
| 967 | int num; |
| 968 | struct image_region reg[]; |
| 969 | }; |
| 970 | |
| 971 | /** |
Heinrich Schuchardt | c6f077a | 2021-02-25 08:02:37 +0100 | [diff] [blame] | 972 | * struct efi_sig_data - A decoded data of struct efi_signature_data |
AKASHI Takahiro | 593e17d | 2020-04-14 11:51:39 +0900 | [diff] [blame] | 973 | * |
| 974 | * This structure represents an internal form of signature in |
| 975 | * signature database. A listed list may represent a signature list. |
| 976 | * |
| 977 | * @next: Pointer to next entry |
Heinrich Schuchardt | c6f077a | 2021-02-25 08:02:37 +0100 | [diff] [blame] | 978 | * @owner: Signature owner |
AKASHI Takahiro | 593e17d | 2020-04-14 11:51:39 +0900 | [diff] [blame] | 979 | * @data: Pointer to signature data |
| 980 | * @size: Size of signature data |
| 981 | */ |
| 982 | struct efi_sig_data { |
| 983 | struct efi_sig_data *next; |
| 984 | efi_guid_t owner; |
| 985 | void *data; |
| 986 | size_t size; |
| 987 | }; |
| 988 | |
| 989 | /** |
Heinrich Schuchardt | c6f077a | 2021-02-25 08:02:37 +0100 | [diff] [blame] | 990 | * struct efi_signature_store - A decoded data of signature database |
AKASHI Takahiro | 593e17d | 2020-04-14 11:51:39 +0900 | [diff] [blame] | 991 | * |
| 992 | * This structure represents an internal form of signature database. |
| 993 | * |
| 994 | * @next: Pointer to next entry |
| 995 | * @sig_type: Signature type |
| 996 | * @sig_data_list: Pointer to signature list |
| 997 | */ |
| 998 | struct efi_signature_store { |
| 999 | struct efi_signature_store *next; |
| 1000 | efi_guid_t sig_type; |
| 1001 | struct efi_sig_data *sig_data_list; |
| 1002 | }; |
| 1003 | |
| 1004 | struct x509_certificate; |
| 1005 | struct pkcs7_message; |
| 1006 | |
Masahisa Kojima | c416f1c | 2022-09-12 17:33:54 +0900 | [diff] [blame] | 1007 | /** |
| 1008 | * struct eficonfig_media_boot_option - boot option for (removable) media device |
| 1009 | * |
| 1010 | * This structure is used to enumerate possible boot option |
| 1011 | * |
| 1012 | * @lo: Serialized load option data |
| 1013 | * @size: Size of serialized load option data |
| 1014 | * @exist: Flag to indicate the load option already exists |
| 1015 | * in Non-volatile load option |
| 1016 | */ |
| 1017 | struct eficonfig_media_boot_option { |
| 1018 | void *lo; |
| 1019 | efi_uintn_t size; |
| 1020 | bool exist; |
| 1021 | }; |
| 1022 | |
AKASHI Takahiro | b330140 | 2022-07-05 14:48:12 +0900 | [diff] [blame] | 1023 | bool efi_hash_regions(struct image_region *regs, int count, |
| 1024 | void **hash, const char *hash_algo, int *len); |
AKASHI Takahiro | 7926dfb | 2020-07-08 14:01:57 +0900 | [diff] [blame] | 1025 | bool efi_signature_lookup_digest(struct efi_image_regions *regs, |
Ilias Apalodimas | 4b63431 | 2022-01-29 00:20:31 +0200 | [diff] [blame] | 1026 | struct efi_signature_store *db, |
| 1027 | bool dbx); |
AKASHI Takahiro | 1115edd | 2020-07-21 19:35:22 +0900 | [diff] [blame] | 1028 | bool efi_signature_verify(struct efi_image_regions *regs, |
| 1029 | struct pkcs7_message *msg, |
| 1030 | struct efi_signature_store *db, |
| 1031 | struct efi_signature_store *dbx); |
AKASHI Takahiro | 52956e5 | 2020-08-14 14:39:23 +0900 | [diff] [blame] | 1032 | static inline bool efi_signature_verify_one(struct efi_image_regions *regs, |
| 1033 | struct pkcs7_message *msg, |
| 1034 | struct efi_signature_store *db) |
| 1035 | { |
| 1036 | return efi_signature_verify(regs, msg, db, NULL); |
| 1037 | } |
AKASHI Takahiro | 11bafb2 | 2020-07-08 14:01:56 +0900 | [diff] [blame] | 1038 | bool efi_signature_check_signers(struct pkcs7_message *msg, |
| 1039 | struct efi_signature_store *dbx); |
AKASHI Takahiro | 593e17d | 2020-04-14 11:51:39 +0900 | [diff] [blame] | 1040 | |
| 1041 | efi_status_t efi_image_region_add(struct efi_image_regions *regs, |
| 1042 | const void *start, const void *end, |
| 1043 | int nocheck); |
AKASHI Takahiro | be6296d | 2020-04-14 11:51:40 +0900 | [diff] [blame] | 1044 | |
| 1045 | void efi_sigstore_free(struct efi_signature_store *sigstore); |
Sughosh Ganu | b4f20a5 | 2020-12-30 19:27:08 +0530 | [diff] [blame] | 1046 | struct efi_signature_store *efi_build_signature_store(void *sig_list, |
| 1047 | efi_uintn_t size); |
AKASHI Takahiro | be6296d | 2020-04-14 11:51:40 +0900 | [diff] [blame] | 1048 | struct efi_signature_store *efi_sigstore_parse_sigdb(u16 *name); |
AKASHI Takahiro | 767f6ee | 2020-04-14 11:51:41 +0900 | [diff] [blame] | 1049 | |
| 1050 | bool efi_secure_boot_enabled(void); |
AKASHI Takahiro | 4540dab | 2020-04-14 11:51:44 +0900 | [diff] [blame] | 1051 | |
Sughosh Ganu | 04be98b | 2020-12-30 19:27:09 +0530 | [diff] [blame] | 1052 | bool efi_capsule_auth_enabled(void); |
| 1053 | |
Masahisa Kojima | 163a0d7 | 2021-05-26 12:09:58 +0900 | [diff] [blame] | 1054 | void *efi_prepare_aligned_image(void *efi, u64 *efi_size); |
| 1055 | |
AKASHI Takahiro | 4540dab | 2020-04-14 11:51:44 +0900 | [diff] [blame] | 1056 | bool efi_image_parse(void *efi, size_t len, struct efi_image_regions **regp, |
| 1057 | WIN_CERTIFICATE **auth, size_t *auth_len); |
AKASHI Takahiro | 593e17d | 2020-04-14 11:51:39 +0900 | [diff] [blame] | 1058 | |
Sughosh Ganu | 201b806 | 2020-12-30 19:27:07 +0530 | [diff] [blame] | 1059 | struct pkcs7_message *efi_parse_pkcs7_header(const void *buf, |
| 1060 | size_t buflen, |
| 1061 | u8 **tmpbuf); |
| 1062 | |
Heinrich Schuchardt | b0dd8cb | 2020-06-28 16:30:29 +0200 | [diff] [blame] | 1063 | /* runtime implementation of memcpy() */ |
| 1064 | void efi_memcpy_runtime(void *dest, const void *src, size_t n); |
| 1065 | |
Paul Barker | 39434a9 | 2022-10-05 13:18:35 +0100 | [diff] [blame] | 1066 | /* commonly used helper functions */ |
Ilias Apalodimas | fe179d7 | 2020-12-31 12:26:46 +0200 | [diff] [blame] | 1067 | u16 *efi_create_indexed_name(u16 *buffer, size_t buffer_size, const char *name, |
| 1068 | unsigned int index); |
Paul Barker | 39434a9 | 2022-10-05 13:18:35 +0100 | [diff] [blame] | 1069 | efi_string_t efi_convert_string(const char *str); |
AKASHI Takahiro | 077153e | 2020-10-29 13:47:46 +0900 | [diff] [blame] | 1070 | |
AKASHI Takahiro | f27c201 | 2020-11-30 18:12:12 +0900 | [diff] [blame] | 1071 | extern const struct efi_firmware_management_protocol efi_fmp_fit; |
AKASHI Takahiro | bb7e71d | 2020-11-17 09:28:00 +0900 | [diff] [blame] | 1072 | extern const struct efi_firmware_management_protocol efi_fmp_raw; |
AKASHI Takahiro | f27c201 | 2020-11-30 18:12:12 +0900 | [diff] [blame] | 1073 | |
AKASHI Takahiro | 2bc27ca | 2020-11-17 09:27:55 +0900 | [diff] [blame] | 1074 | /* Capsule update */ |
| 1075 | efi_status_t EFIAPI efi_update_capsule( |
| 1076 | struct efi_capsule_header **capsule_header_array, |
| 1077 | efi_uintn_t capsule_count, |
| 1078 | u64 scatter_gather_list); |
| 1079 | efi_status_t EFIAPI efi_query_capsule_caps( |
| 1080 | struct efi_capsule_header **capsule_header_array, |
| 1081 | efi_uintn_t capsule_count, |
| 1082 | u64 *maximum_capsule_size, |
| 1083 | u32 *reset_type); |
| 1084 | |
Sughosh Ganu | 04be98b | 2020-12-30 19:27:09 +0530 | [diff] [blame] | 1085 | efi_status_t efi_capsule_authenticate(const void *capsule, |
| 1086 | efi_uintn_t capsule_size, |
| 1087 | void **image, efi_uintn_t *image_size); |
| 1088 | |
Simon Glass | 156ccbc | 2022-01-23 12:55:12 -0700 | [diff] [blame] | 1089 | #define EFI_CAPSULE_DIR u"\\EFI\\UpdateCapsule\\" |
AKASHI Takahiro | c74cd8b | 2020-11-17 09:27:56 +0900 | [diff] [blame] | 1090 | |
Jose Marinho | 64a8aae | 2021-03-02 17:26:38 +0000 | [diff] [blame] | 1091 | /** |
Sughosh Ganu | 741ef86 | 2022-04-15 11:29:34 +0530 | [diff] [blame] | 1092 | * struct efi_fw_image - Information on firmware images updatable through |
| 1093 | * capsule update |
| 1094 | * |
| 1095 | * This structure gives information about the firmware images on the platform |
| 1096 | * which can be updated through the capsule update mechanism |
| 1097 | * |
| 1098 | * @image_type_id: Image GUID. Same value is to be used in the capsule |
| 1099 | * @fw_name: Name of the firmware image |
| 1100 | * @image_index: Image Index, same as value passed to SetImage FMP |
| 1101 | * function |
| 1102 | */ |
| 1103 | struct efi_fw_image { |
| 1104 | efi_guid_t image_type_id; |
| 1105 | u16 *fw_name; |
| 1106 | u8 image_index; |
| 1107 | }; |
| 1108 | |
| 1109 | /** |
| 1110 | * struct efi_capsule_update_info - Information needed for capsule updates |
| 1111 | * |
| 1112 | * This structure provides information needed for performing firmware |
| 1113 | * updates. The structure needs to be initialised per platform, for all |
| 1114 | * platforms which enable capsule updates |
| 1115 | * |
| 1116 | * @dfu_string: String used to populate dfu_alt_info |
Masahisa Kojima | cccea18 | 2023-06-07 14:41:51 +0900 | [diff] [blame] | 1117 | * @num_images: The number of images array entries |
Sughosh Ganu | 741ef86 | 2022-04-15 11:29:34 +0530 | [diff] [blame] | 1118 | * @images: Pointer to an array of updatable images |
| 1119 | */ |
| 1120 | struct efi_capsule_update_info { |
| 1121 | const char *dfu_string; |
Masahisa Kojima | cccea18 | 2023-06-07 14:41:51 +0900 | [diff] [blame] | 1122 | int num_images; |
Sughosh Ganu | 741ef86 | 2022-04-15 11:29:34 +0530 | [diff] [blame] | 1123 | struct efi_fw_image *images; |
| 1124 | }; |
| 1125 | |
| 1126 | extern struct efi_capsule_update_info update_info; |
Sughosh Ganu | 741ef86 | 2022-04-15 11:29:34 +0530 | [diff] [blame] | 1127 | |
| 1128 | /** |
Jose Marinho | 64a8aae | 2021-03-02 17:26:38 +0000 | [diff] [blame] | 1129 | * Install the ESRT system table. |
| 1130 | * |
Heinrich Schuchardt | 185f812 | 2022-01-19 18:05:50 +0100 | [diff] [blame] | 1131 | * Return: status code |
Jose Marinho | 64a8aae | 2021-03-02 17:26:38 +0000 | [diff] [blame] | 1132 | */ |
| 1133 | efi_status_t efi_esrt_register(void); |
| 1134 | |
| 1135 | /** |
Jose Marinho | 6b92c17 | 2021-12-23 14:51:07 +0000 | [diff] [blame] | 1136 | * efi_ecpt_register() - Install the ECPT system table. |
| 1137 | * |
| 1138 | * Return: status code |
| 1139 | */ |
| 1140 | efi_status_t efi_ecpt_register(void); |
| 1141 | |
| 1142 | /** |
Jose Marinho | 64a8aae | 2021-03-02 17:26:38 +0000 | [diff] [blame] | 1143 | * efi_esrt_populate() - Populates the ESRT entries from the FMP instances |
| 1144 | * present in the system. |
| 1145 | * If an ESRT already exists, the old ESRT is replaced in the system table. |
| 1146 | * The memory of the old ESRT is deallocated. |
| 1147 | * |
| 1148 | * Return: |
| 1149 | * - EFI_SUCCESS if the ESRT is correctly created |
| 1150 | * - error code otherwise. |
| 1151 | */ |
| 1152 | efi_status_t efi_esrt_populate(void); |
Ilias Apalodimas | 6e0184b | 2021-06-22 17:38:53 +0300 | [diff] [blame] | 1153 | efi_status_t efi_load_capsule_drivers(void); |
Ruchika Gupta | 34287ef | 2021-11-29 13:09:44 +0530 | [diff] [blame] | 1154 | |
| 1155 | efi_status_t platform_get_eventlog(struct udevice *dev, u64 *addr, u32 *sz); |
Masahisa Kojima | 87d7914 | 2022-09-12 17:33:50 +0900 | [diff] [blame] | 1156 | |
| 1157 | efi_status_t efi_locate_handle_buffer_int(enum efi_locate_search_type search_type, |
| 1158 | const efi_guid_t *protocol, void *search_key, |
| 1159 | efi_uintn_t *no_handles, efi_handle_t **buffer); |
| 1160 | |
| 1161 | efi_status_t efi_open_volume_int(struct efi_simple_file_system_protocol *this, |
| 1162 | struct efi_file_handle **root); |
| 1163 | efi_status_t efi_file_open_int(struct efi_file_handle *this, |
| 1164 | struct efi_file_handle **new_handle, |
| 1165 | u16 *file_name, u64 open_mode, |
| 1166 | u64 attributes); |
| 1167 | efi_status_t efi_file_close_int(struct efi_file_handle *file); |
| 1168 | efi_status_t efi_file_read_int(struct efi_file_handle *this, |
| 1169 | efi_uintn_t *buffer_size, void *buffer); |
| 1170 | efi_status_t efi_file_setpos_int(struct efi_file_handle *file, u64 pos); |
| 1171 | |
| 1172 | typedef efi_status_t (*efi_console_filter_func)(struct efi_input_key *key); |
| 1173 | efi_status_t efi_console_get_u16_string |
| 1174 | (struct efi_simple_text_input_protocol *cin, |
| 1175 | u16 *buf, efi_uintn_t count, efi_console_filter_func filer_func, |
| 1176 | int row, int col); |
| 1177 | |
| 1178 | efi_status_t efi_disk_get_device_name(const efi_handle_t handle, char *buf, int size); |
| 1179 | |
Heinrich Schuchardt | a9f20ef | 2023-02-10 09:01:13 +0100 | [diff] [blame] | 1180 | /** |
| 1181 | * efi_add_known_memory() - add memory banks to EFI memory map |
| 1182 | * |
| 1183 | * This weak function may be overridden for specific architectures. |
| 1184 | */ |
| 1185 | void efi_add_known_memory(void); |
| 1186 | |
Heinrich Schuchardt | cd9e18d | 2017-10-18 18:13:07 +0200 | [diff] [blame] | 1187 | #endif /* _EFI_LOADER_H */ |