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> |
Heinrich Schuchardt | da620cf | 2022-10-06 07:29:41 +0200 | [diff] [blame] | 13 | #include <event.h> |
Simon Glass | 0f2af88 | 2020-05-10 11:40:05 -0600 | [diff] [blame] | 14 | #include <log.h> |
Alexander Graf | 4e0c1c1 | 2016-03-04 01:09:58 +0100 | [diff] [blame] | 15 | #include <part_efi.h> |
| 16 | #include <efi_api.h> |
AKASHI Takahiro | 2c0f9f7 | 2020-04-21 09:38:38 +0900 | [diff] [blame] | 17 | #include <image.h> |
AKASHI Takahiro | 0e104e3 | 2020-04-14 11:51:44 +0900 | [diff] [blame] | 18 | #include <pe.h> |
Simon Glass | 97f9bd4 | 2021-07-02 12:36:16 -0600 | [diff] [blame] | 19 | #include <linux/list.h> |
| 20 | #include <linux/oid_registry.h> |
Alexander Graf | c15d921 | 2016-03-04 01:09:59 +0100 | [diff] [blame] | 21 | |
Simon Glass | 655306c | 2020-05-10 11:39:58 -0600 | [diff] [blame] | 22 | struct blk_desc; |
AKASHI Takahiro | 4cbba2b | 2021-07-20 14:57:02 +0900 | [diff] [blame] | 23 | struct jmp_buf_data; |
Simon Glass | 655306c | 2020-05-10 11:39:58 -0600 | [diff] [blame] | 24 | |
Simon Glass | 16fc74a | 2019-09-25 08:11:32 -0600 | [diff] [blame] | 25 | static inline int guidcmp(const void *g1, const void *g2) |
| 26 | { |
| 27 | return memcmp(g1, g2, sizeof(efi_guid_t)); |
| 28 | } |
| 29 | |
Sughosh Ganu | 196f66d | 2019-12-29 00:01:04 +0530 | [diff] [blame] | 30 | static inline void *guidcpy(void *dst, const void *src) |
| 31 | { |
| 32 | return memcpy(dst, src, sizeof(efi_guid_t)); |
| 33 | } |
| 34 | |
Stephen Warren | d0de806 | 2018-08-30 15:43:43 -0600 | [diff] [blame] | 35 | #if CONFIG_IS_ENABLED(EFI_LOADER) |
Alexander Graf | c15d921 | 2016-03-04 01:09:59 +0100 | [diff] [blame] | 36 | |
Simon Glass | 97f9bd4 | 2021-07-02 12:36:16 -0600 | [diff] [blame] | 37 | /** |
| 38 | * __efi_runtime_data - declares a non-const variable for EFI runtime section |
| 39 | * |
| 40 | * This macro indicates that a variable is non-const and should go into the |
| 41 | * EFI runtime section, and thus still be available when the OS is running. |
| 42 | * |
| 43 | * Only use on variables not declared const. |
| 44 | * |
| 45 | * Example: |
| 46 | * |
| 47 | * :: |
| 48 | * |
| 49 | * static __efi_runtime_data my_computed_table[256]; |
| 50 | */ |
| 51 | #define __efi_runtime_data __section(".data.efi_runtime") |
| 52 | |
| 53 | /** |
| 54 | * __efi_runtime_rodata - declares a read-only variable for EFI runtime section |
| 55 | * |
| 56 | * This macro indicates that a variable is read-only (const) and should go into |
| 57 | * the EFI runtime section, and thus still be available when the OS is running. |
| 58 | * |
| 59 | * Only use on variables also declared const. |
| 60 | * |
| 61 | * Example: |
| 62 | * |
| 63 | * :: |
| 64 | * |
| 65 | * static const __efi_runtime_rodata my_const_table[] = { 1, 2, 3 }; |
| 66 | */ |
| 67 | #define __efi_runtime_rodata __section(".rodata.efi_runtime") |
| 68 | |
| 69 | /** |
| 70 | * __efi_runtime - declares a function for EFI runtime section |
| 71 | * |
| 72 | * This macro indicates that a function should go into the EFI runtime section, |
| 73 | * and thus still be available when the OS is running. |
| 74 | * |
| 75 | * Example: |
| 76 | * |
| 77 | * :: |
| 78 | * |
| 79 | * static __efi_runtime compute_my_table(void); |
| 80 | */ |
| 81 | #define __efi_runtime __section(".text.efi_runtime") |
| 82 | |
| 83 | /* |
| 84 | * Call this with mmio_ptr as the _pointer_ to a pointer to an MMIO region |
| 85 | * to make it available at runtime |
| 86 | */ |
| 87 | efi_status_t efi_add_runtime_mmio(void *mmio_ptr, u64 len); |
| 88 | |
| 89 | /* |
| 90 | * Special case handler for error/abort that just tries to dtrt to get |
| 91 | * back to u-boot world |
| 92 | */ |
| 93 | void efi_restore_gd(void); |
| 94 | /* Call this to set the current device name */ |
| 95 | void efi_set_bootdev(const char *dev, const char *devnr, const char *path, |
| 96 | void *buffer, size_t buffer_size); |
| 97 | /* Called by networking code to memorize the dhcp ack package */ |
| 98 | void efi_net_set_dhcp_ack(void *pkt, int len); |
| 99 | /* Print information about all loaded images */ |
| 100 | void efi_print_image_infos(void *pc); |
| 101 | |
| 102 | /* Hook at initialization */ |
| 103 | efi_status_t efi_launch_capsules(void); |
| 104 | |
| 105 | #else /* CONFIG_IS_ENABLED(EFI_LOADER) */ |
| 106 | |
| 107 | /* Without CONFIG_EFI_LOADER we don't have a runtime section, stub it out */ |
| 108 | #define __efi_runtime_data |
| 109 | #define __efi_runtime_rodata |
| 110 | #define __efi_runtime |
| 111 | static inline efi_status_t efi_add_runtime_mmio(void *mmio_ptr, u64 len) |
| 112 | { |
| 113 | return EFI_SUCCESS; |
| 114 | } |
| 115 | |
| 116 | /* No loader configured, stub out EFI_ENTRY */ |
| 117 | static inline void efi_restore_gd(void) { } |
| 118 | static inline void efi_set_bootdev(const char *dev, const char *devnr, |
| 119 | const char *path, void *buffer, |
| 120 | size_t buffer_size) { } |
| 121 | static inline void efi_net_set_dhcp_ack(void *pkt, int len) { } |
| 122 | static inline void efi_print_image_infos(void *pc) { } |
| 123 | static inline efi_status_t efi_launch_capsules(void) |
| 124 | { |
| 125 | return EFI_SUCCESS; |
| 126 | } |
| 127 | |
| 128 | #endif /* CONFIG_IS_ENABLED(EFI_LOADER) */ |
Alexander Graf | 4e0c1c1 | 2016-03-04 01:09:58 +0100 | [diff] [blame] | 129 | |
Heinrich Schuchardt | 2f528c2 | 2018-06-28 12:45:32 +0200 | [diff] [blame] | 130 | /* Maximum number of configuration tables */ |
| 131 | #define EFI_MAX_CONFIGURATION_TABLES 16 |
| 132 | |
Heinrich Schuchardt | 79d7202 | 2018-09-20 21:58:23 +0200 | [diff] [blame] | 133 | /* GUID used by the root node */ |
| 134 | #define U_BOOT_GUID \ |
| 135 | EFI_GUID(0xe61d73b9, 0xa384, 0x4acc, \ |
| 136 | 0xae, 0xab, 0x82, 0xe8, 0x28, 0xf3, 0x62, 0x8b) |
Tobias Waldekranz | 3215268 | 2023-02-16 16:33:55 +0100 | [diff] [blame] | 137 | /* GUID used as root for blkmap devices */ |
| 138 | #define U_BOOT_BLKMAP_DEV_GUID \ |
| 139 | EFI_GUID(0x4cad859d, 0xd644, 0x42ff, \ |
| 140 | 0x87, 0x0b, 0xc0, 0x2e, 0xac, 0x05, 0x58, 0x63) |
AKASHI Takahiro | 659a626 | 2019-09-12 13:52:35 +0900 | [diff] [blame] | 141 | /* GUID used as host device on sandbox */ |
| 142 | #define U_BOOT_HOST_DEV_GUID \ |
| 143 | EFI_GUID(0xbbe4e671, 0x5773, 0x4ea1, \ |
| 144 | 0x9a, 0xab, 0x3a, 0x7d, 0xbf, 0x40, 0xc4, 0x82) |
Heinrich Schuchardt | c770aaa | 2020-05-20 22:39:35 +0200 | [diff] [blame] | 145 | /* GUID used as root for virtio devices */ |
| 146 | #define U_BOOT_VIRTIO_DEV_GUID \ |
| 147 | EFI_GUID(0x63293792, 0xadf5, 0x9325, \ |
| 148 | 0xb9, 0x9f, 0x4e, 0x0e, 0x45, 0x5c, 0x1b, 0x1e) |
Heinrich Schuchardt | 79d7202 | 2018-09-20 21:58:23 +0200 | [diff] [blame] | 149 | |
Masahisa Kojima | c5ff0a0 | 2022-09-12 17:33:50 +0900 | [diff] [blame] | 150 | /* GUID for the auto generated boot menu entry */ |
| 151 | #define EFICONFIG_AUTO_GENERATED_ENTRY_GUID \ |
| 152 | EFI_GUID(0x38c1acc1, 0x9fc0, 0x41f0, \ |
| 153 | 0xb9, 0x01, 0xfa, 0x74, 0xd6, 0xd6, 0xe4, 0xde) |
| 154 | |
Heinrich Schuchardt | 6fbb8ac | 2019-11-28 06:46:09 +0100 | [diff] [blame] | 155 | /* Use internal device tree when starting UEFI application */ |
Heinrich Schuchardt | 6246741 | 2019-12-08 01:07:01 +0100 | [diff] [blame] | 156 | #define EFI_FDT_USE_INTERNAL NULL |
Heinrich Schuchardt | 6fbb8ac | 2019-11-28 06:46:09 +0100 | [diff] [blame] | 157 | |
AKASHI Takahiro | 0b27575 | 2019-04-16 13:24:20 +0900 | [diff] [blame] | 158 | /* Root node */ |
| 159 | extern efi_handle_t efi_root; |
| 160 | |
Heinrich Schuchardt | de9bdc6 | 2020-03-19 18:21:58 +0000 | [diff] [blame] | 161 | /* Set to EFI_SUCCESS when initialized */ |
| 162 | extern efi_status_t efi_obj_list_initialized; |
| 163 | |
Heinrich Schuchardt | 628dbd7 | 2020-11-12 21:26:28 +0100 | [diff] [blame] | 164 | /* Flag used by the selftest to avoid detaching devices in ExitBootServices() */ |
| 165 | extern bool efi_st_keep_devices; |
| 166 | |
Heinrich Schuchardt | a993173 | 2020-03-19 15:16:31 +0100 | [diff] [blame] | 167 | /* EFI system partition */ |
| 168 | extern struct efi_system_partition { |
Simon Glass | fada3f9 | 2022-09-17 09:00:09 -0600 | [diff] [blame] | 169 | enum uclass_id uclass_id; |
Heinrich Schuchardt | a993173 | 2020-03-19 15:16:31 +0100 | [diff] [blame] | 170 | int devnum; |
| 171 | u8 part; |
| 172 | } efi_system_partition; |
| 173 | |
Rob Clark | 86789d5 | 2017-07-27 08:04:18 -0400 | [diff] [blame] | 174 | int __efi_entry_check(void); |
| 175 | int __efi_exit_check(void); |
Heinrich Schuchardt | 4d66489 | 2017-08-18 17:45:16 +0200 | [diff] [blame] | 176 | const char *__efi_nesting(void); |
Rob Clark | e7896c3 | 2017-07-27 08:04:19 -0400 | [diff] [blame] | 177 | const char *__efi_nesting_inc(void); |
| 178 | const char *__efi_nesting_dec(void); |
Rob Clark | 86789d5 | 2017-07-27 08:04:18 -0400 | [diff] [blame] | 179 | |
Rob Clark | 63ea77a | 2017-07-27 08:04:17 -0400 | [diff] [blame] | 180 | /* |
| 181 | * Enter the u-boot world from UEFI: |
| 182 | */ |
Alexander Graf | c15d921 | 2016-03-04 01:09:59 +0100 | [diff] [blame] | 183 | #define EFI_ENTRY(format, ...) do { \ |
Rob Clark | 86789d5 | 2017-07-27 08:04:18 -0400 | [diff] [blame] | 184 | assert(__efi_entry_check()); \ |
Rob Clark | e7896c3 | 2017-07-27 08:04:19 -0400 | [diff] [blame] | 185 | debug("%sEFI: Entry %s(" format ")\n", __efi_nesting_inc(), \ |
| 186 | __func__, ##__VA_ARGS__); \ |
Alexander Graf | c15d921 | 2016-03-04 01:09:59 +0100 | [diff] [blame] | 187 | } while(0) |
Alexander Graf | c15d921 | 2016-03-04 01:09:59 +0100 | [diff] [blame] | 188 | |
Rob Clark | 63ea77a | 2017-07-27 08:04:17 -0400 | [diff] [blame] | 189 | /* |
| 190 | * Exit the u-boot world back to UEFI: |
| 191 | */ |
Rob Clark | 84a19a0 | 2017-07-24 10:31:52 -0400 | [diff] [blame] | 192 | #define EFI_EXIT(ret) ({ \ |
xypron.glpk@gmx.de | 8f9dd92 | 2017-08-17 18:57:36 +0200 | [diff] [blame] | 193 | typeof(ret) _r = ret; \ |
Rob Clark | e7896c3 | 2017-07-27 08:04:19 -0400 | [diff] [blame] | 194 | debug("%sEFI: Exit: %s: %u\n", __efi_nesting_dec(), \ |
xypron.glpk@gmx.de | 8f9dd92 | 2017-08-17 18:57:36 +0200 | [diff] [blame] | 195 | __func__, (u32)((uintptr_t) _r & ~EFI_ERROR_MASK)); \ |
Rob Clark | 86789d5 | 2017-07-27 08:04:18 -0400 | [diff] [blame] | 196 | assert(__efi_exit_check()); \ |
| 197 | _r; \ |
Rob Clark | 84a19a0 | 2017-07-24 10:31:52 -0400 | [diff] [blame] | 198 | }) |
Alexander Graf | c15d921 | 2016-03-04 01:09:59 +0100 | [diff] [blame] | 199 | |
Rob Clark | 63ea77a | 2017-07-27 08:04:17 -0400 | [diff] [blame] | 200 | /* |
Heinrich Schuchardt | 91e5b8a | 2017-09-15 10:06:10 +0200 | [diff] [blame] | 201 | * Call non-void UEFI function from u-boot and retrieve return value: |
| 202 | */ |
| 203 | #define EFI_CALL(exp) ({ \ |
| 204 | debug("%sEFI: Call: %s\n", __efi_nesting_inc(), #exp); \ |
| 205 | assert(__efi_exit_check()); \ |
| 206 | typeof(exp) _r = exp; \ |
| 207 | assert(__efi_entry_check()); \ |
| 208 | debug("%sEFI: %lu returned by %s\n", __efi_nesting_dec(), \ |
| 209 | (unsigned long)((uintptr_t)_r & ~EFI_ERROR_MASK), #exp); \ |
| 210 | _r; \ |
| 211 | }) |
| 212 | |
| 213 | /* |
| 214 | * Call void UEFI function from u-boot: |
Rob Clark | 63ea77a | 2017-07-27 08:04:17 -0400 | [diff] [blame] | 215 | */ |
Heinrich Schuchardt | 91e5b8a | 2017-09-15 10:06:10 +0200 | [diff] [blame] | 216 | #define EFI_CALL_VOID(exp) do { \ |
Rob Clark | e7896c3 | 2017-07-27 08:04:19 -0400 | [diff] [blame] | 217 | debug("%sEFI: Call: %s\n", __efi_nesting_inc(), #exp); \ |
Rob Clark | 86789d5 | 2017-07-27 08:04:18 -0400 | [diff] [blame] | 218 | assert(__efi_exit_check()); \ |
Rob Clark | 63ea77a | 2017-07-27 08:04:17 -0400 | [diff] [blame] | 219 | exp; \ |
Rob Clark | 86789d5 | 2017-07-27 08:04:18 -0400 | [diff] [blame] | 220 | assert(__efi_entry_check()); \ |
Rob Clark | e7896c3 | 2017-07-27 08:04:19 -0400 | [diff] [blame] | 221 | debug("%sEFI: Return From: %s\n", __efi_nesting_dec(), #exp); \ |
Rob Clark | 63ea77a | 2017-07-27 08:04:17 -0400 | [diff] [blame] | 222 | } while(0) |
| 223 | |
Heinrich Schuchardt | 4d66489 | 2017-08-18 17:45:16 +0200 | [diff] [blame] | 224 | /* |
Heinrich Schuchardt | 3d2abc3 | 2018-01-11 08:16:01 +0100 | [diff] [blame] | 225 | * Write an indented message with EFI prefix |
Heinrich Schuchardt | 4d66489 | 2017-08-18 17:45:16 +0200 | [diff] [blame] | 226 | */ |
Heinrich Schuchardt | 3d2abc3 | 2018-01-11 08:16:01 +0100 | [diff] [blame] | 227 | #define EFI_PRINT(format, ...) ({ \ |
| 228 | debug("%sEFI: " format, __efi_nesting(), \ |
| 229 | ##__VA_ARGS__); \ |
Heinrich Schuchardt | 4d66489 | 2017-08-18 17:45:16 +0200 | [diff] [blame] | 230 | }) |
| 231 | |
Alexander Graf | 59254d6 | 2018-04-23 07:59:47 +0200 | [diff] [blame] | 232 | #ifdef CONFIG_SYS_CACHELINE_SIZE |
| 233 | #define EFI_CACHELINE_SIZE CONFIG_SYS_CACHELINE_SIZE |
| 234 | #else |
| 235 | /* Just use the greatest cache flush alignment requirement I'm aware of */ |
| 236 | #define EFI_CACHELINE_SIZE 128 |
| 237 | #endif |
| 238 | |
Masahisa Kojima | c5ff0a0 | 2022-09-12 17:33:50 +0900 | [diff] [blame] | 239 | /* max bootmenu title size for volume selection */ |
| 240 | #define BOOTMENU_DEVICE_NAME_MAX 16 |
| 241 | |
Heinrich Schuchardt | 0f233c4 | 2018-07-02 12:53:55 +0200 | [diff] [blame] | 242 | /* Key identifying current memory map */ |
| 243 | extern efi_uintn_t efi_memory_map_key; |
| 244 | |
Alexander Graf | 0bd425a | 2016-03-04 01:10:01 +0100 | [diff] [blame] | 245 | extern struct efi_runtime_services efi_runtime_services; |
Alexander Graf | c15d921 | 2016-03-04 01:09:59 +0100 | [diff] [blame] | 246 | extern struct efi_system_table systab; |
| 247 | |
Heinrich Schuchardt | 580c13b | 2017-10-26 19:25:59 +0200 | [diff] [blame] | 248 | extern struct efi_simple_text_output_protocol efi_con_out; |
Heinrich Schuchardt | 3dabffd | 2018-09-08 10:20:10 +0200 | [diff] [blame] | 249 | extern struct efi_simple_text_input_protocol efi_con_in; |
Heinrich Schuchardt | 580c13b | 2017-10-26 19:25:59 +0200 | [diff] [blame] | 250 | extern struct efi_console_control_protocol efi_console_control; |
xypron.glpk@gmx.de | 3c042b2 | 2017-07-11 22:06:25 +0200 | [diff] [blame] | 251 | 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] | 252 | /* implementation of the EFI_DEVICE_PATH_UTILITIES_PROTOCOL */ |
| 253 | extern const struct efi_device_path_utilities_protocol |
| 254 | efi_device_path_utilities; |
Heinrich Schuchardt | 18ed8cf | 2019-05-16 18:19:00 +0200 | [diff] [blame] | 255 | /* current version of the EFI_UNICODE_COLLATION_PROTOCOL */ |
Heinrich Schuchardt | e59072a | 2018-09-04 19:34:58 +0200 | [diff] [blame] | 256 | extern const struct efi_unicode_collation_protocol |
Heinrich Schuchardt | b325884 | 2019-05-16 07:52:58 +0200 | [diff] [blame] | 257 | efi_unicode_collation_protocol2; |
AKASHI Takahiro | ca8aa71 | 2019-01-21 12:13:00 +0900 | [diff] [blame] | 258 | extern const struct efi_hii_config_routing_protocol efi_hii_config_routing; |
| 259 | extern const struct efi_hii_config_access_protocol efi_hii_config_access; |
Leif Lindholm | 5aab1b8 | 2019-01-21 12:12:57 +0900 | [diff] [blame] | 260 | extern const struct efi_hii_database_protocol efi_hii_database; |
| 261 | extern const struct efi_hii_string_protocol efi_hii_string; |
Alexander Graf | 4aacacc | 2016-03-04 01:10:00 +0100 | [diff] [blame] | 262 | |
Rob Clark | 85dd721 | 2017-09-13 18:05:30 -0400 | [diff] [blame] | 263 | uint16_t *efi_dp_str(struct efi_device_path *dp); |
| 264 | |
Masahisa Kojima | c5ff0a0 | 2022-09-12 17:33:50 +0900 | [diff] [blame] | 265 | /* GUID for the auto generated boot menu entry */ |
| 266 | extern const efi_guid_t efi_guid_bootmenu_auto_generated; |
| 267 | |
Heinrich Schuchardt | 79d7202 | 2018-09-20 21:58:23 +0200 | [diff] [blame] | 268 | /* GUID of the U-Boot root node */ |
| 269 | extern const efi_guid_t efi_u_boot_guid; |
AKASHI Takahiro | 659a626 | 2019-09-12 13:52:35 +0900 | [diff] [blame] | 270 | #ifdef CONFIG_SANDBOX |
| 271 | /* GUID of U-Boot host device on sandbox */ |
| 272 | extern const efi_guid_t efi_guid_host_dev; |
| 273 | #endif |
Heinrich Schuchardt | 405afb5 | 2018-01-19 20:24:45 +0100 | [diff] [blame] | 274 | /* GUID of the EFI_BLOCK_IO_PROTOCOL */ |
| 275 | extern const efi_guid_t efi_block_io_guid; |
Rob Clark | c84c110 | 2017-09-13 18:05:38 -0400 | [diff] [blame] | 276 | extern const efi_guid_t efi_global_variable_guid; |
Alexander Graf | 4aacacc | 2016-03-04 01:10:00 +0100 | [diff] [blame] | 277 | extern const efi_guid_t efi_guid_console_control; |
Alexander Graf | 4e0c1c1 | 2016-03-04 01:09:58 +0100 | [diff] [blame] | 278 | extern const efi_guid_t efi_guid_device_path; |
Heinrich Schuchardt | e840b9c | 2022-03-19 07:04:03 +0100 | [diff] [blame] | 279 | /* GUID of the EFI system partition */ |
| 280 | extern const efi_guid_t efi_system_partition_guid; |
Heinrich Schuchardt | 760255f | 2018-01-11 08:16:02 +0100 | [diff] [blame] | 281 | /* GUID of the EFI_DRIVER_BINDING_PROTOCOL */ |
| 282 | extern const efi_guid_t efi_guid_driver_binding_protocol; |
Heinrich Schuchardt | 672d99e | 2018-02-18 15:17:51 +0100 | [diff] [blame] | 283 | /* event group ExitBootServices() invoked */ |
| 284 | extern const efi_guid_t efi_guid_event_group_exit_boot_services; |
| 285 | /* event group SetVirtualAddressMap() invoked */ |
| 286 | extern const efi_guid_t efi_guid_event_group_virtual_address_change; |
| 287 | /* event group memory map changed */ |
| 288 | extern const efi_guid_t efi_guid_event_group_memory_map_change; |
| 289 | /* event group boot manager about to boot */ |
| 290 | extern const efi_guid_t efi_guid_event_group_ready_to_boot; |
| 291 | /* event group ResetSystem() invoked (before ExitBootServices) */ |
| 292 | extern const efi_guid_t efi_guid_event_group_reset_system; |
Heinrich Schuchardt | 44ab21b | 2018-03-03 15:29:03 +0100 | [diff] [blame] | 293 | /* GUID of the device tree table */ |
| 294 | extern const efi_guid_t efi_guid_fdt; |
Alexander Graf | 4e0c1c1 | 2016-03-04 01:09:58 +0100 | [diff] [blame] | 295 | extern const efi_guid_t efi_guid_loaded_image; |
AKASHI Takahiro | bbe13da | 2019-03-27 13:40:32 +0900 | [diff] [blame] | 296 | 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] | 297 | extern const efi_guid_t efi_guid_device_path_to_text_protocol; |
Rob Clark | 5314203 | 2017-09-13 18:05:34 -0400 | [diff] [blame] | 298 | extern const efi_guid_t efi_simple_file_system_protocol_guid; |
| 299 | extern const efi_guid_t efi_file_info_guid; |
Heinrich Schuchardt | 37fb4b9 | 2018-04-04 15:42:11 +0200 | [diff] [blame] | 300 | /* GUID for file system information */ |
| 301 | extern const efi_guid_t efi_file_system_info_guid; |
Leif Lindholm | b6e6fdc | 2018-03-09 17:43:21 +0100 | [diff] [blame] | 302 | extern const efi_guid_t efi_guid_device_path_utilities_protocol; |
Heinrich Schuchardt | 18ed8cf | 2019-05-16 18:19:00 +0200 | [diff] [blame] | 303 | /* GUID of the deprecated Unicode collation protocol */ |
| 304 | extern const efi_guid_t efi_guid_unicode_collation_protocol; |
Heinrich Schuchardt | 485956d | 2020-12-04 03:33:41 +0100 | [diff] [blame] | 305 | /* GUIDs of the Load File and Load File2 protocol */ |
| 306 | extern const efi_guid_t efi_guid_load_file_protocol; |
| 307 | extern const efi_guid_t efi_guid_load_file2_protocol; |
Heinrich Schuchardt | e59072a | 2018-09-04 19:34:58 +0200 | [diff] [blame] | 308 | /* GUID of the Unicode collation protocol */ |
Heinrich Schuchardt | b325884 | 2019-05-16 07:52:58 +0200 | [diff] [blame] | 309 | extern const efi_guid_t efi_guid_unicode_collation_protocol2; |
AKASHI Takahiro | ca8aa71 | 2019-01-21 12:13:00 +0900 | [diff] [blame] | 310 | extern const efi_guid_t efi_guid_hii_config_routing_protocol; |
| 311 | extern const efi_guid_t efi_guid_hii_config_access_protocol; |
Leif Lindholm | 5aab1b8 | 2019-01-21 12:12:57 +0900 | [diff] [blame] | 312 | extern const efi_guid_t efi_guid_hii_database_protocol; |
| 313 | extern const efi_guid_t efi_guid_hii_string_protocol; |
AKASHI Takahiro | 1faaca4 | 2020-04-14 11:51:39 +0900 | [diff] [blame] | 314 | /* GUIDs for authentication */ |
| 315 | extern const efi_guid_t efi_guid_image_security_database; |
| 316 | extern const efi_guid_t efi_guid_sha256; |
| 317 | extern const efi_guid_t efi_guid_cert_x509; |
| 318 | extern const efi_guid_t efi_guid_cert_x509_sha256; |
Ilias Apalodimas | 34db9b1 | 2022-05-06 15:36:00 +0300 | [diff] [blame] | 319 | extern const efi_guid_t efi_guid_cert_x509_sha384; |
| 320 | extern const efi_guid_t efi_guid_cert_x509_sha512; |
AKASHI Takahiro | b0f49ee | 2020-04-14 11:51:41 +0900 | [diff] [blame] | 321 | extern const efi_guid_t efi_guid_cert_type_pkcs7; |
Alexander Graf | 4e0c1c1 | 2016-03-04 01:09:58 +0100 | [diff] [blame] | 322 | |
Sughosh Ganu | 693a4f4 | 2019-12-29 00:01:06 +0530 | [diff] [blame] | 323 | /* GUID of RNG protocol */ |
| 324 | extern const efi_guid_t efi_guid_rng_protocol; |
AKASHI Takahiro | 473d9b3 | 2020-11-17 09:27:55 +0900 | [diff] [blame] | 325 | /* GUID of capsule update result */ |
| 326 | extern const efi_guid_t efi_guid_capsule_report; |
AKASHI Takahiro | 0d96378 | 2020-11-30 18:12:11 +0900 | [diff] [blame] | 327 | /* GUID of firmware management protocol */ |
| 328 | extern const efi_guid_t efi_guid_firmware_management_protocol; |
Jose Marinho | ebb61ee | 2021-03-02 17:26:38 +0000 | [diff] [blame] | 329 | /* GUID for the ESRT */ |
| 330 | extern const efi_guid_t efi_esrt_guid; |
Masahisa Kojima | cd1fe7d | 2021-10-26 17:27:24 +0900 | [diff] [blame] | 331 | /* GUID of the SMBIOS table */ |
| 332 | extern const efi_guid_t smbios_guid; |
Masahisa Kojima | c5ff0a0 | 2022-09-12 17:33:50 +0900 | [diff] [blame] | 333 | /*GUID of console */ |
| 334 | extern const efi_guid_t efi_guid_text_input_protocol; |
Masahisa Kojima | a93282c | 2023-01-24 15:56:15 +0900 | [diff] [blame] | 335 | extern const efi_guid_t efi_guid_text_output_protocol; |
Sughosh Ganu | 693a4f4 | 2019-12-29 00:01:06 +0530 | [diff] [blame] | 336 | |
Marek Behún | 6950450 | 2021-05-20 13:23:56 +0200 | [diff] [blame] | 337 | extern char __efi_runtime_start[], __efi_runtime_stop[]; |
| 338 | extern char __efi_runtime_rel_start[], __efi_runtime_rel_stop[]; |
Alexander Graf | 0bd425a | 2016-03-04 01:10:01 +0100 | [diff] [blame] | 339 | |
Heinrich Schuchardt | 2e4b41f | 2019-05-21 17:51:35 +0200 | [diff] [blame] | 340 | /** |
| 341 | * struct efi_open_protocol_info_item - open protocol info item |
| 342 | * |
Heinrich Schuchardt | a277d3a | 2018-01-11 08:15:57 +0100 | [diff] [blame] | 343 | * When a protocol is opened a open protocol info entry is created. |
| 344 | * These are maintained in a list. |
Heinrich Schuchardt | 2e4b41f | 2019-05-21 17:51:35 +0200 | [diff] [blame] | 345 | * |
| 346 | * @link: link to the list of open protocol info entries of a protocol |
| 347 | * @info: information about the opening of a protocol |
Heinrich Schuchardt | a277d3a | 2018-01-11 08:15:57 +0100 | [diff] [blame] | 348 | */ |
| 349 | struct efi_open_protocol_info_item { |
Heinrich Schuchardt | a277d3a | 2018-01-11 08:15:57 +0100 | [diff] [blame] | 350 | struct list_head link; |
| 351 | struct efi_open_protocol_info_entry info; |
| 352 | }; |
| 353 | |
Heinrich Schuchardt | 2e4b41f | 2019-05-21 17:51:35 +0200 | [diff] [blame] | 354 | /** |
| 355 | * struct efi_handler - single protocol interface of a handle |
| 356 | * |
Alexander Graf | c15d921 | 2016-03-04 01:09:59 +0100 | [diff] [blame] | 357 | * When the UEFI payload wants to open a protocol on an object to get its |
| 358 | * interface (usually a struct with callback functions), this struct maps the |
Heinrich Schuchardt | a277d3a | 2018-01-11 08:15:57 +0100 | [diff] [blame] | 359 | * protocol GUID to the respective protocol interface |
Heinrich Schuchardt | 2e4b41f | 2019-05-21 17:51:35 +0200 | [diff] [blame] | 360 | * |
| 361 | * @link: link to the list of protocols of a handle |
| 362 | * @guid: GUID of the protocol |
| 363 | * @protocol_interface: protocol interface |
Heinrich Schuchardt | 6eb30c1 | 2021-02-25 08:02:37 +0100 | [diff] [blame] | 364 | * @open_infos: link to the list of open protocol info items |
Heinrich Schuchardt | a277d3a | 2018-01-11 08:15:57 +0100 | [diff] [blame] | 365 | */ |
Alexander Graf | c15d921 | 2016-03-04 01:09:59 +0100 | [diff] [blame] | 366 | struct efi_handler { |
Heinrich Schuchardt | 99ce206 | 2017-11-26 14:05:17 +0100 | [diff] [blame] | 367 | struct list_head link; |
Heinrich Schuchardt | 2a22db9 | 2022-03-09 19:56:23 +0100 | [diff] [blame] | 368 | const efi_guid_t guid; |
xypron.glpk@gmx.de | c35c924 | 2017-07-11 22:06:14 +0200 | [diff] [blame] | 369 | void *protocol_interface; |
Heinrich Schuchardt | a277d3a | 2018-01-11 08:15:57 +0100 | [diff] [blame] | 370 | struct list_head open_infos; |
Alexander Graf | c15d921 | 2016-03-04 01:09:59 +0100 | [diff] [blame] | 371 | }; |
| 372 | |
Heinrich Schuchardt | adb50d0 | 2018-09-26 05:27:55 +0200 | [diff] [blame] | 373 | /** |
Heinrich Schuchardt | b27ced4 | 2019-05-01 14:20:18 +0200 | [diff] [blame] | 374 | * enum efi_object_type - type of EFI object |
| 375 | * |
| 376 | * In UnloadImage we must be able to identify if the handle relates to a |
| 377 | * started image. |
| 378 | */ |
| 379 | enum efi_object_type { |
Heinrich Schuchardt | 6eb30c1 | 2021-02-25 08:02:37 +0100 | [diff] [blame] | 380 | /** @EFI_OBJECT_TYPE_UNDEFINED: undefined image type */ |
Heinrich Schuchardt | b27ced4 | 2019-05-01 14:20:18 +0200 | [diff] [blame] | 381 | EFI_OBJECT_TYPE_UNDEFINED = 0, |
Heinrich Schuchardt | 6eb30c1 | 2021-02-25 08:02:37 +0100 | [diff] [blame] | 382 | /** @EFI_OBJECT_TYPE_U_BOOT_FIRMWARE: U-Boot firmware */ |
Heinrich Schuchardt | 2e0a790 | 2019-05-05 16:55:06 +0200 | [diff] [blame] | 383 | EFI_OBJECT_TYPE_U_BOOT_FIRMWARE, |
Heinrich Schuchardt | 6eb30c1 | 2021-02-25 08:02:37 +0100 | [diff] [blame] | 384 | /** @EFI_OBJECT_TYPE_LOADED_IMAGE: loaded image (not started) */ |
Heinrich Schuchardt | b27ced4 | 2019-05-01 14:20:18 +0200 | [diff] [blame] | 385 | EFI_OBJECT_TYPE_LOADED_IMAGE, |
Heinrich Schuchardt | 6eb30c1 | 2021-02-25 08:02:37 +0100 | [diff] [blame] | 386 | /** @EFI_OBJECT_TYPE_STARTED_IMAGE: started image */ |
Heinrich Schuchardt | b27ced4 | 2019-05-01 14:20:18 +0200 | [diff] [blame] | 387 | EFI_OBJECT_TYPE_STARTED_IMAGE, |
| 388 | }; |
| 389 | |
| 390 | /** |
Heinrich Schuchardt | adb50d0 | 2018-09-26 05:27:55 +0200 | [diff] [blame] | 391 | * struct efi_object - dereferenced EFI handle |
| 392 | * |
| 393 | * @link: pointers to put the handle into a linked list |
| 394 | * @protocols: linked list with the protocol interfaces installed on this |
| 395 | * handle |
Heinrich Schuchardt | 6eb30c1 | 2021-02-25 08:02:37 +0100 | [diff] [blame] | 396 | * @type: image type if the handle relates to an image |
Masahisa Kojima | c961108 | 2022-07-22 11:39:10 +0900 | [diff] [blame] | 397 | * @dev: pointer to the DM device which is associated with this EFI handle |
Heinrich Schuchardt | adb50d0 | 2018-09-26 05:27:55 +0200 | [diff] [blame] | 398 | * |
| 399 | * UEFI offers a flexible and expandable object model. The objects in the UEFI |
| 400 | * API are devices, drivers, and loaded images. struct efi_object is our storage |
| 401 | * structure for these objects. |
| 402 | * |
| 403 | * When including this structure into a larger structure always put it first so |
| 404 | * that when deleting a handle the whole encompassing structure can be freed. |
Alexander Graf | c15d921 | 2016-03-04 01:09:59 +0100 | [diff] [blame] | 405 | * |
Heinrich Schuchardt | adb50d0 | 2018-09-26 05:27:55 +0200 | [diff] [blame] | 406 | * A pointer to this structure is referred to as a handle. Typedef efi_handle_t |
| 407 | * has been created for such pointers. |
Alexander Graf | c15d921 | 2016-03-04 01:09:59 +0100 | [diff] [blame] | 408 | */ |
| 409 | struct efi_object { |
| 410 | /* Every UEFI object is part of a global object list */ |
| 411 | struct list_head link; |
Heinrich Schuchardt | 99ce206 | 2017-11-26 14:05:17 +0100 | [diff] [blame] | 412 | /* The list of protocols */ |
| 413 | struct list_head protocols; |
Heinrich Schuchardt | b27ced4 | 2019-05-01 14:20:18 +0200 | [diff] [blame] | 414 | enum efi_object_type type; |
Masahisa Kojima | c961108 | 2022-07-22 11:39:10 +0900 | [diff] [blame] | 415 | struct udevice *dev; |
Alexander Graf | c15d921 | 2016-03-04 01:09:59 +0100 | [diff] [blame] | 416 | }; |
| 417 | |
AKASHI Takahiro | 0e104e3 | 2020-04-14 11:51:44 +0900 | [diff] [blame] | 418 | enum efi_image_auth_status { |
| 419 | EFI_IMAGE_AUTH_FAILED = 0, |
| 420 | EFI_IMAGE_AUTH_PASSED, |
| 421 | }; |
| 422 | |
xypron.glpk@gmx.de | 3070823 | 2017-07-18 20:17:18 +0200 | [diff] [blame] | 423 | /** |
Heinrich Schuchardt | 3c3a735 | 2018-09-23 17:21:51 +0200 | [diff] [blame] | 424 | * struct efi_loaded_image_obj - handle of a loaded image |
Heinrich Schuchardt | 7292872 | 2018-09-26 05:27:56 +0200 | [diff] [blame] | 425 | * |
| 426 | * @header: EFI object header |
Heinrich Schuchardt | 3d44512 | 2019-04-30 17:57:30 +0200 | [diff] [blame] | 427 | * @exit_status: exit status passed to Exit() |
| 428 | * @exit_data_size: exit data size passed to Exit() |
| 429 | * @exit_data: exit data passed to Exit() |
Heinrich Schuchardt | 93b40d6 | 2020-12-28 22:42:51 +0100 | [diff] [blame] | 430 | * @exit_jmp: long jump buffer for returning from started image |
Heinrich Schuchardt | 7292872 | 2018-09-26 05:27:56 +0200 | [diff] [blame] | 431 | * @entry: entry address of the relocated image |
Heinrich Schuchardt | 93b40d6 | 2020-12-28 22:42:51 +0100 | [diff] [blame] | 432 | * @image_type: indicates if the image is an applicition or a driver |
| 433 | * @auth_status: indicates if the image is authenticated |
Heinrich Schuchardt | 3c3a735 | 2018-09-23 17:21:51 +0200 | [diff] [blame] | 434 | */ |
| 435 | struct efi_loaded_image_obj { |
Heinrich Schuchardt | 7292872 | 2018-09-26 05:27:56 +0200 | [diff] [blame] | 436 | struct efi_object header; |
Heinrich Schuchardt | 026c7ec | 2020-12-28 23:24:40 +0100 | [diff] [blame] | 437 | efi_status_t *exit_status; |
Heinrich Schuchardt | 3d44512 | 2019-04-30 17:57:30 +0200 | [diff] [blame] | 438 | efi_uintn_t *exit_data_size; |
| 439 | u16 **exit_data; |
Heinrich Schuchardt | 026c7ec | 2020-12-28 23:24:40 +0100 | [diff] [blame] | 440 | struct jmp_buf_data *exit_jmp; |
Heinrich Schuchardt | 3c3a735 | 2018-09-23 17:21:51 +0200 | [diff] [blame] | 441 | EFIAPI efi_status_t (*entry)(efi_handle_t image_handle, |
| 442 | struct efi_system_table *st); |
Heinrich Schuchardt | 3758752 | 2019-05-01 20:07:04 +0200 | [diff] [blame] | 443 | u16 image_type; |
AKASHI Takahiro | 0e104e3 | 2020-04-14 11:51:44 +0900 | [diff] [blame] | 444 | enum efi_image_auth_status auth_status; |
Heinrich Schuchardt | 3c3a735 | 2018-09-23 17:21:51 +0200 | [diff] [blame] | 445 | }; |
| 446 | |
| 447 | /** |
xypron.glpk@gmx.de | 3070823 | 2017-07-18 20:17:18 +0200 | [diff] [blame] | 448 | * struct efi_event |
| 449 | * |
Heinrich Schuchardt | 370c7a8 | 2018-02-18 15:17:50 +0100 | [diff] [blame] | 450 | * @link: Link to list of all events |
Heinrich Schuchardt | 35c0cf6 | 2019-06-05 21:00:39 +0200 | [diff] [blame] | 451 | * @queue_link: Link to the list of queued events |
xypron.glpk@gmx.de | 3070823 | 2017-07-18 20:17:18 +0200 | [diff] [blame] | 452 | * @type: Type of event, see efi_create_event |
| 453 | * @notify_tpl: Task priority level of notifications |
Heinrich Schuchardt | 6eb30c1 | 2021-02-25 08:02:37 +0100 | [diff] [blame] | 454 | * @notify_function: Function to call when the event is triggered |
xypron.glpk@gmx.de | 3070823 | 2017-07-18 20:17:18 +0200 | [diff] [blame] | 455 | * @notify_context: Data to be passed to the notify function |
Heinrich Schuchardt | bf7f169 | 2018-02-18 15:17:52 +0100 | [diff] [blame] | 456 | * @group: Event group |
Heinrich Schuchardt | 370c7a8 | 2018-02-18 15:17:50 +0100 | [diff] [blame] | 457 | * @trigger_time: Period of the timer |
| 458 | * @trigger_next: Next time to trigger the timer |
xypron.glpk@gmx.de | 3070823 | 2017-07-18 20:17:18 +0200 | [diff] [blame] | 459 | * @trigger_type: Type of timer, see efi_set_timer |
Heinrich Schuchardt | 370c7a8 | 2018-02-18 15:17:50 +0100 | [diff] [blame] | 460 | * @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] | 461 | */ |
| 462 | struct efi_event { |
Heinrich Schuchardt | 370c7a8 | 2018-02-18 15:17:50 +0100 | [diff] [blame] | 463 | struct list_head link; |
Heinrich Schuchardt | 35c0cf6 | 2019-06-05 21:00:39 +0200 | [diff] [blame] | 464 | struct list_head queue_link; |
xypron.glpk@gmx.de | 3ecc6bd | 2017-07-19 19:22:34 +0200 | [diff] [blame] | 465 | uint32_t type; |
Heinrich Schuchardt | f8d4ec3 | 2017-11-06 21:17:47 +0100 | [diff] [blame] | 466 | efi_uintn_t notify_tpl; |
xypron.glpk@gmx.de | 3070823 | 2017-07-18 20:17:18 +0200 | [diff] [blame] | 467 | void (EFIAPI *notify_function)(struct efi_event *event, void *context); |
| 468 | void *notify_context; |
Heinrich Schuchardt | bf7f169 | 2018-02-18 15:17:52 +0100 | [diff] [blame] | 469 | const efi_guid_t *group; |
xypron.glpk@gmx.de | 3070823 | 2017-07-18 20:17:18 +0200 | [diff] [blame] | 470 | u64 trigger_next; |
| 471 | u64 trigger_time; |
xypron.glpk@gmx.de | 3ecc6bd | 2017-07-19 19:22:34 +0200 | [diff] [blame] | 472 | enum efi_timer_delay trigger_type; |
Heinrich Schuchardt | 1bbee39 | 2017-10-04 15:03:24 +0200 | [diff] [blame] | 473 | bool is_signaled; |
xypron.glpk@gmx.de | 3070823 | 2017-07-18 20:17:18 +0200 | [diff] [blame] | 474 | }; |
| 475 | |
Alexander Graf | c15d921 | 2016-03-04 01:09:59 +0100 | [diff] [blame] | 476 | /* This list contains all UEFI objects we know of */ |
| 477 | extern struct list_head efi_obj_list; |
Heinrich Schuchardt | bf7f169 | 2018-02-18 15:17:52 +0100 | [diff] [blame] | 478 | /* List of all events */ |
| 479 | extern struct list_head efi_events; |
Alexander Graf | c15d921 | 2016-03-04 01:09:59 +0100 | [diff] [blame] | 480 | |
Heinrich Schuchardt | 6eec42d | 2019-05-04 17:27:54 +0200 | [diff] [blame] | 481 | /** |
Heinrich Schuchardt | d375e75 | 2019-05-21 18:19:01 +0200 | [diff] [blame] | 482 | * struct efi_protocol_notification - handle for notified protocol |
| 483 | * |
| 484 | * When a protocol interface is installed for which an event was registered with |
| 485 | * the RegisterProtocolNotify() service this structure is used to hold the |
| 486 | * handle on which the protocol interface was installed. |
| 487 | * |
| 488 | * @link: link to list of all handles notified for this event |
| 489 | * @handle: handle on which the notified protocol interface was installed |
| 490 | */ |
| 491 | struct efi_protocol_notification { |
| 492 | struct list_head link; |
| 493 | efi_handle_t handle; |
| 494 | }; |
| 495 | |
| 496 | /** |
Heinrich Schuchardt | 6eb30c1 | 2021-02-25 08:02:37 +0100 | [diff] [blame] | 497 | * struct efi_register_notify_event - event registered by |
| 498 | * RegisterProtocolNotify() |
Heinrich Schuchardt | 6eec42d | 2019-05-04 17:27:54 +0200 | [diff] [blame] | 499 | * |
| 500 | * The address of this structure serves as registration value. |
| 501 | * |
Heinrich Schuchardt | d375e75 | 2019-05-21 18:19:01 +0200 | [diff] [blame] | 502 | * @link: link to list of all registered events |
| 503 | * @event: registered event. The same event may registered for multiple |
| 504 | * GUIDs. |
| 505 | * @protocol: protocol for which the event is registered |
| 506 | * @handles: linked list of all handles on which the notified protocol was |
| 507 | * installed |
Heinrich Schuchardt | 6eec42d | 2019-05-04 17:27:54 +0200 | [diff] [blame] | 508 | */ |
| 509 | struct efi_register_notify_event { |
| 510 | struct list_head link; |
| 511 | struct efi_event *event; |
| 512 | efi_guid_t protocol; |
Heinrich Schuchardt | d375e75 | 2019-05-21 18:19:01 +0200 | [diff] [blame] | 513 | struct list_head handles; |
Heinrich Schuchardt | 6eec42d | 2019-05-04 17:27:54 +0200 | [diff] [blame] | 514 | }; |
| 515 | |
AKASHI Takahiro | a36dc25 | 2022-04-19 10:05:11 +0900 | [diff] [blame] | 516 | /* called at pre-initialization */ |
| 517 | int efi_init_early(void); |
AKASHI Takahiro | 7e0badb | 2018-12-30 15:16:55 +0100 | [diff] [blame] | 518 | /* Initialize efi execution environment */ |
| 519 | efi_status_t efi_init_obj_list(void); |
Heinrich Schuchardt | 761908e | 2022-06-14 08:02:03 +0200 | [diff] [blame] | 520 | /* Set up console modes */ |
| 521 | void efi_setup_console_size(void); |
Heinrich Schuchardt | 6246741 | 2019-12-08 01:07:01 +0100 | [diff] [blame] | 522 | /* Install device tree */ |
| 523 | efi_status_t efi_install_fdt(void *fdt); |
Heinrich Schuchardt | ffb9059 | 2019-12-07 20:51:06 +0100 | [diff] [blame] | 524 | /* Run loaded UEFI image */ |
| 525 | 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] | 526 | /* Initialize variable services */ |
| 527 | efi_status_t efi_init_variables(void); |
Heinrich Schuchardt | 2ac6258 | 2019-06-20 15:25:48 +0200 | [diff] [blame] | 528 | /* Notify ExitBootServices() is called */ |
| 529 | void efi_variables_boot_exit_notify(void); |
Masahisa Kojima | 1ac19bb | 2021-08-13 16:12:41 +0900 | [diff] [blame] | 530 | efi_status_t efi_tcg2_notify_exit_boot_services_failed(void); |
Masahisa Kojima | 8173cd4 | 2021-08-13 16:12:40 +0900 | [diff] [blame] | 531 | /* Measure efi application invocation */ |
Masahisa Kojima | 6460c3e | 2021-10-26 17:27:25 +0900 | [diff] [blame] | 532 | efi_status_t efi_tcg2_measure_efi_app_invocation(struct efi_loaded_image_obj *handle); |
Masahisa Kojima | 8173cd4 | 2021-08-13 16:12:40 +0900 | [diff] [blame] | 533 | /* Measure efi application exit */ |
| 534 | efi_status_t efi_tcg2_measure_efi_app_exit(void); |
Etienne Carriere | b906435 | 2023-02-16 17:29:48 +0100 | [diff] [blame] | 535 | /* Measure DTB */ |
| 536 | efi_status_t efi_tcg2_measure_dtb(void *dtb); |
Heinrich Schuchardt | 79d7202 | 2018-09-20 21:58:23 +0200 | [diff] [blame] | 537 | /* Called by bootefi to initialize root node */ |
| 538 | efi_status_t efi_root_node_register(void); |
Heinrich Schuchardt | 15070db | 2018-06-28 12:45:31 +0200 | [diff] [blame] | 539 | /* Called by bootefi to initialize runtime */ |
| 540 | efi_status_t efi_initialize_system_table(void); |
Heinrich Schuchardt | 1943dbb | 2019-07-05 17:42:16 +0200 | [diff] [blame] | 541 | /* efi_runtime_detach() - detach unimplemented runtime functions */ |
| 542 | void efi_runtime_detach(void); |
Heinrich Schuchardt | 699b7c6 | 2020-03-24 18:05:22 +0100 | [diff] [blame] | 543 | /* efi_convert_pointer() - convert pointer to virtual address */ |
| 544 | efi_status_t EFIAPI efi_convert_pointer(efi_uintn_t debug_disposition, |
| 545 | void **address); |
Heinrich Schuchardt | 2c1e224 | 2020-12-13 10:30:24 +0100 | [diff] [blame] | 546 | /* Carve out DT reserved memory ranges */ |
| 547 | void efi_carve_out_dt_rsv(void *fdt); |
Ilias Apalodimas | e4e5660 | 2022-01-03 14:07:37 +0200 | [diff] [blame] | 548 | /* Purge unused kaslr-seed */ |
| 549 | void efi_try_purge_kaslr_seed(void *fdt); |
xypron.glpk@gmx.de | 54c7a8e | 2017-07-18 20:17:22 +0200 | [diff] [blame] | 550 | /* Called by bootefi to make console interface available */ |
Heinrich Schuchardt | a92e9ab | 2018-10-02 06:08:26 +0200 | [diff] [blame] | 551 | efi_status_t efi_console_register(void); |
Heinrich Schuchardt | a02228f | 2022-08-31 16:37:35 +0200 | [diff] [blame] | 552 | /* Called by efi_init_obj_list() to proble all block devices */ |
| 553 | efi_status_t efi_disks_register(void); |
Heinrich Schuchardt | c63f68f | 2020-09-25 12:50:19 +0200 | [diff] [blame] | 554 | /* Called by efi_init_obj_list() to install EFI_RNG_PROTOCOL */ |
| 555 | efi_status_t efi_rng_register(void); |
Ilias Apalodimas | 590fef6 | 2020-11-11 11:18:11 +0200 | [diff] [blame] | 556 | /* Called by efi_init_obj_list() to install EFI_TCG2_PROTOCOL */ |
| 557 | efi_status_t efi_tcg2_register(void); |
Sunil V L | 279d1c8 | 2022-01-28 20:48:44 +0530 | [diff] [blame] | 558 | /* Called by efi_init_obj_list() to install RISCV_EFI_BOOT_PROTOCOL */ |
| 559 | efi_status_t efi_riscv_register(void); |
Masahisa Kojima | 0fd4379 | 2021-12-07 14:15:31 +0900 | [diff] [blame] | 560 | /* Called by efi_init_obj_list() to do initial measurement */ |
| 561 | efi_status_t efi_tcg2_do_initial_measurement(void); |
Masahisa Kojima | 70be5a6 | 2021-05-26 12:09:58 +0900 | [diff] [blame] | 562 | /* measure the pe-coff image, extend PCR and add Event Log */ |
| 563 | efi_status_t tcg2_measure_pe_image(void *efi, u64 efi_size, |
| 564 | struct efi_loaded_image_obj *handle, |
| 565 | struct efi_loaded_image *loaded_image_info); |
Heinrich Schuchardt | 6f3de6b | 2018-01-19 20:24:47 +0100 | [diff] [blame] | 566 | /* Create handles and protocols for the partitions of a block device */ |
| 567 | int efi_disk_create_partitions(efi_handle_t parent, struct blk_desc *desc, |
Simon Glass | fada3f9 | 2022-09-17 09:00:09 -0600 | [diff] [blame] | 568 | const char *uclass_idname, int diskid, |
Heinrich Schuchardt | 6f3de6b | 2018-01-19 20:24:47 +0100 | [diff] [blame] | 569 | const char *pdevname); |
Alexander Graf | d65783d | 2016-03-15 18:38:21 +0100 | [diff] [blame] | 570 | /* Called by bootefi to make GOP (graphical) interface available */ |
Heinrich Schuchardt | b91c084 | 2018-03-03 15:28:55 +0100 | [diff] [blame] | 571 | efi_status_t efi_gop_register(void); |
Alexander Graf | 94c4b99 | 2016-05-06 21:01:01 +0200 | [diff] [blame] | 572 | /* Called by bootefi to make the network interface available */ |
Heinrich Schuchardt | 6f5c73f | 2018-03-03 15:28:56 +0100 | [diff] [blame] | 573 | efi_status_t efi_net_register(void); |
Heinrich Schuchardt | 18081d4 | 2017-10-18 18:13:04 +0200 | [diff] [blame] | 574 | /* Called by bootefi to make the watchdog available */ |
Heinrich Schuchardt | f2704cc | 2018-03-03 15:28:57 +0100 | [diff] [blame] | 575 | efi_status_t efi_watchdog_register(void); |
Ilias Apalodimas | 3510ba7 | 2020-02-21 09:55:45 +0200 | [diff] [blame] | 576 | efi_status_t efi_initrd_register(void); |
Ilias Apalodimas | 7e05279 | 2022-10-16 11:36:32 +0300 | [diff] [blame] | 577 | efi_status_t efi_initrd_deregister(void); |
Alexander Graf | 66f96e1 | 2016-08-19 01:23:29 +0200 | [diff] [blame] | 578 | /* Called by bootefi to make SMBIOS tables available */ |
Simon Glass | 2e2858f | 2018-05-16 09:42:19 -0600 | [diff] [blame] | 579 | /** |
Bin Meng | 2cfbdae | 2018-06-27 20:38:03 -0700 | [diff] [blame] | 580 | * efi_acpi_register() - write out ACPI tables |
| 581 | * |
| 582 | * Called by bootefi to make ACPI tables available |
| 583 | * |
Heinrich Schuchardt | 47b4c02 | 2022-01-19 18:05:50 +0100 | [diff] [blame] | 584 | * Return: 0 if OK, -ENOMEM if no memory is available for the tables |
Bin Meng | 2cfbdae | 2018-06-27 20:38:03 -0700 | [diff] [blame] | 585 | */ |
| 586 | efi_status_t efi_acpi_register(void); |
| 587 | /** |
Simon Glass | 2e2858f | 2018-05-16 09:42:19 -0600 | [diff] [blame] | 588 | * efi_smbios_register() - write out SMBIOS tables |
| 589 | * |
| 590 | * Called by bootefi to make SMBIOS tables available |
| 591 | * |
Heinrich Schuchardt | 47b4c02 | 2022-01-19 18:05:50 +0100 | [diff] [blame] | 592 | * Return: 0 if OK, -ENOMEM if no memory is available for the tables |
Simon Glass | 2e2858f | 2018-05-16 09:42:19 -0600 | [diff] [blame] | 593 | */ |
Heinrich Schuchardt | 7a369c4 | 2018-03-03 15:28:54 +0100 | [diff] [blame] | 594 | efi_status_t efi_smbios_register(void); |
Alexander Graf | 94c4b99 | 2016-05-06 21:01:01 +0200 | [diff] [blame] | 595 | |
Rob Clark | 5314203 | 2017-09-13 18:05:34 -0400 | [diff] [blame] | 596 | struct efi_simple_file_system_protocol * |
| 597 | efi_fs_from_path(struct efi_device_path *fp); |
| 598 | |
Heinrich Schuchardt | 18081d4 | 2017-10-18 18:13:04 +0200 | [diff] [blame] | 599 | /* Called by efi_set_watchdog_timer to reset the timer */ |
| 600 | efi_status_t efi_set_watchdog(unsigned long timeout); |
Alexander Graf | 94c4b99 | 2016-05-06 21:01:01 +0200 | [diff] [blame] | 601 | |
Alexander Graf | c15d921 | 2016-03-04 01:09:59 +0100 | [diff] [blame] | 602 | /* Called from places to check whether a timer expired */ |
| 603 | void efi_timer_check(void); |
Heinrich Schuchardt | ad6e0f7 | 2021-01-12 12:40:32 +0100 | [diff] [blame] | 604 | /* Check if a buffer contains a PE-COFF image */ |
| 605 | efi_status_t efi_check_pe(void *buffer, size_t size, void **nt_header); |
Alexander Graf | c15d921 | 2016-03-04 01:09:59 +0100 | [diff] [blame] | 606 | /* PE loader implementation */ |
AKASHI Takahiro | 0e104e3 | 2020-04-14 11:51:44 +0900 | [diff] [blame] | 607 | efi_status_t efi_load_pe(struct efi_loaded_image_obj *handle, |
| 608 | void *efi, size_t efi_size, |
Heinrich Schuchardt | 408fbcc | 2018-12-26 12:49:09 +0100 | [diff] [blame] | 609 | struct efi_loaded_image *loaded_image_info); |
Alexander Graf | c15d921 | 2016-03-04 01:09:59 +0100 | [diff] [blame] | 610 | /* Called once to store the pristine gd pointer */ |
| 611 | void efi_save_gd(void); |
Alexander Graf | 0bd425a | 2016-03-04 01:10:01 +0100 | [diff] [blame] | 612 | /* Call this to relocate the runtime section to an address space */ |
| 613 | void efi_runtime_relocate(ulong offset, struct efi_mem_desc *map); |
Rui Miguel Silva | 433f15a | 2022-05-11 10:55:40 +0100 | [diff] [blame] | 614 | /* Call this to get image parameters */ |
| 615 | void efi_get_image_parameters(void **img_addr, size_t *img_size); |
Heinrich Schuchardt | 967d7de | 2017-11-26 14:05:23 +0100 | [diff] [blame] | 616 | /* Add a new object to the object list. */ |
Heinrich Schuchardt | adb50d0 | 2018-09-26 05:27:55 +0200 | [diff] [blame] | 617 | void efi_add_handle(efi_handle_t obj); |
Heinrich Schuchardt | eb6106e | 2017-10-26 19:25:49 +0200 | [diff] [blame] | 618 | /* Create handle */ |
Heinrich Schuchardt | b7cb8b4 | 2018-01-11 08:16:09 +0100 | [diff] [blame] | 619 | efi_status_t efi_create_handle(efi_handle_t *handle); |
Heinrich Schuchardt | 7d13546 | 2017-12-04 18:03:02 +0100 | [diff] [blame] | 620 | /* Delete handle */ |
Heinrich Schuchardt | adb50d0 | 2018-09-26 05:27:55 +0200 | [diff] [blame] | 621 | void efi_delete_handle(efi_handle_t obj); |
Heinrich Schuchardt | 274cc87 | 2017-11-06 21:17:50 +0100 | [diff] [blame] | 622 | /* 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] | 623 | struct efi_object *efi_search_obj(const efi_handle_t handle); |
AKASHI Takahiro | 537a693 | 2022-04-28 17:09:38 +0900 | [diff] [blame] | 624 | /* Locate device_path handle */ |
| 625 | efi_status_t EFIAPI efi_locate_device_path(const efi_guid_t *protocol, |
| 626 | struct efi_device_path **device_path, |
| 627 | efi_handle_t *device); |
AKASHI Takahiro | b0ad905 | 2019-03-05 14:53:31 +0900 | [diff] [blame] | 628 | /* Load image */ |
| 629 | efi_status_t EFIAPI efi_load_image(bool boot_policy, |
| 630 | efi_handle_t parent_image, |
| 631 | struct efi_device_path *file_path, |
| 632 | void *source_buffer, |
| 633 | efi_uintn_t source_size, |
| 634 | efi_handle_t *image_handle); |
Heinrich Schuchardt | 2f8eb08 | 2018-12-26 13:28:09 +0100 | [diff] [blame] | 635 | /* Start image */ |
| 636 | efi_status_t EFIAPI efi_start_image(efi_handle_t image_handle, |
| 637 | efi_uintn_t *exit_data_size, |
| 638 | u16 **exit_data); |
AKASHI Takahiro | b0ad905 | 2019-03-05 14:53:31 +0900 | [diff] [blame] | 639 | /* Unload image */ |
| 640 | efi_status_t EFIAPI efi_unload_image(efi_handle_t image_handle); |
Heinrich Schuchardt | 5aef61d | 2017-10-26 19:25:53 +0200 | [diff] [blame] | 641 | /* Find a protocol on a handle */ |
Heinrich Schuchardt | b7cb8b4 | 2018-01-11 08:16:09 +0100 | [diff] [blame] | 642 | efi_status_t efi_search_protocol(const efi_handle_t handle, |
Heinrich Schuchardt | 5aef61d | 2017-10-26 19:25:53 +0200 | [diff] [blame] | 643 | const efi_guid_t *protocol_guid, |
| 644 | struct efi_handler **handler); |
| 645 | /* Install new protocol on a handle */ |
Heinrich Schuchardt | b7cb8b4 | 2018-01-11 08:16:09 +0100 | [diff] [blame] | 646 | efi_status_t efi_add_protocol(const efi_handle_t handle, |
| 647 | const efi_guid_t *protocol, |
Heinrich Schuchardt | 5aef61d | 2017-10-26 19:25:53 +0200 | [diff] [blame] | 648 | void *protocol_interface); |
Heinrich Schuchardt | 9c89d14 | 2020-01-10 12:33:59 +0100 | [diff] [blame] | 649 | /* Open protocol */ |
| 650 | efi_status_t efi_protocol_open(struct efi_handler *handler, |
| 651 | void **protocol_interface, void *agent_handle, |
| 652 | void *controller_handle, uint32_t attributes); |
| 653 | |
Heinrich Schuchardt | 5aef61d | 2017-10-26 19:25:53 +0200 | [diff] [blame] | 654 | /* Delete protocol from a handle */ |
Heinrich Schuchardt | b7cb8b4 | 2018-01-11 08:16:09 +0100 | [diff] [blame] | 655 | efi_status_t efi_remove_protocol(const efi_handle_t handle, |
| 656 | const efi_guid_t *protocol, |
Heinrich Schuchardt | 5aef61d | 2017-10-26 19:25:53 +0200 | [diff] [blame] | 657 | void *protocol_interface); |
Heinrich Schuchardt | 744d83e | 2019-04-12 06:59:49 +0200 | [diff] [blame] | 658 | /* Install multiple protocol interfaces */ |
Ilias Apalodimas | 8ac0ebe | 2022-10-06 16:08:46 +0300 | [diff] [blame] | 659 | efi_status_t EFIAPI |
| 660 | efi_install_multiple_protocol_interfaces(efi_handle_t *handle, ...); |
| 661 | efi_status_t EFIAPI |
| 662 | efi_uninstall_multiple_protocol_interfaces(efi_handle_t handle, ...); |
AKASHI Takahiro | d99b1b3 | 2020-03-17 11:12:36 +0900 | [diff] [blame] | 663 | /* Get handles that support a given protocol */ |
| 664 | efi_status_t EFIAPI efi_locate_handle_buffer( |
| 665 | enum efi_locate_search_type search_type, |
| 666 | const efi_guid_t *protocol, void *search_key, |
| 667 | efi_uintn_t *no_handles, efi_handle_t **buffer); |
Heinrich Schuchardt | 5e39433 | 2022-10-07 15:18:15 +0200 | [diff] [blame] | 668 | /* Close a previously opened protocol interface */ |
| 669 | efi_status_t efi_close_protocol(efi_handle_t handle, const efi_guid_t *protocol, |
| 670 | efi_handle_t agent_handle, |
| 671 | efi_handle_t controller_handle); |
AKASHI Takahiro | d99b1b3 | 2020-03-17 11:12:36 +0900 | [diff] [blame] | 672 | /* Open a protocol interface */ |
| 673 | efi_status_t EFIAPI efi_handle_protocol(efi_handle_t handle, |
| 674 | const efi_guid_t *protocol, |
| 675 | void **protocol_interface); |
xypron.glpk@gmx.de | 852a0e177 | 2017-07-18 20:17:20 +0200 | [diff] [blame] | 676 | /* Call this to create an event */ |
Heinrich Schuchardt | f8d4ec3 | 2017-11-06 21:17:47 +0100 | [diff] [blame] | 677 | 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] | 678 | void (EFIAPI *notify_function) ( |
| 679 | struct efi_event *event, |
| 680 | void *context), |
Heinrich Schuchardt | bf7f169 | 2018-02-18 15:17:52 +0100 | [diff] [blame] | 681 | void *notify_context, efi_guid_t *group, |
| 682 | struct efi_event **event); |
xypron.glpk@gmx.de | a587fd1 | 2017-07-18 20:17:21 +0200 | [diff] [blame] | 683 | /* Call this to set a timer */ |
xypron.glpk@gmx.de | 3ecc6bd | 2017-07-19 19:22:34 +0200 | [diff] [blame] | 684 | 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] | 685 | uint64_t trigger_time); |
xypron.glpk@gmx.de | 54c7a8e | 2017-07-18 20:17:22 +0200 | [diff] [blame] | 686 | /* Call this to signal an event */ |
Heinrich Schuchardt | 7b4b8d86 | 2019-06-07 06:47:01 +0200 | [diff] [blame] | 687 | void efi_signal_event(struct efi_event *event); |
Alexander Graf | 0bd425a | 2016-03-04 01:10:01 +0100 | [diff] [blame] | 688 | |
AKASHI Takahiro | ba647af | 2022-05-12 11:29:01 +0900 | [diff] [blame] | 689 | /* return true if the device is removable */ |
| 690 | bool efi_disk_is_removable(efi_handle_t handle); |
| 691 | |
Rob Clark | 5314203 | 2017-09-13 18:05:34 -0400 | [diff] [blame] | 692 | /* open file system: */ |
| 693 | struct efi_simple_file_system_protocol *efi_simple_file_system( |
| 694 | struct blk_desc *desc, int part, struct efi_device_path *dp); |
| 695 | |
| 696 | /* open file from device-path: */ |
| 697 | struct efi_file_handle *efi_file_from_path(struct efi_device_path *fp); |
| 698 | |
Jose Marinho | ebb61ee | 2021-03-02 17:26:38 +0000 | [diff] [blame] | 699 | /* Registers a callback function for a notification event. */ |
| 700 | efi_status_t EFIAPI efi_register_protocol_notify(const efi_guid_t *protocol, |
| 701 | struct efi_event *event, |
| 702 | void **registration); |
Ilias Apalodimas | aa0f755 | 2021-03-17 21:54:59 +0200 | [diff] [blame] | 703 | efi_status_t efi_file_size(struct efi_file_handle *fh, efi_uintn_t *size); |
| 704 | |
| 705 | /* get a device path from a Boot#### option */ |
| 706 | struct efi_device_path *efi_get_dp_from_boot(const efi_guid_t guid); |
| 707 | |
Ilias Apalodimas | 34db9b1 | 2022-05-06 15:36:00 +0300 | [diff] [blame] | 708 | /* get len, string (used in u-boot crypto from a guid */ |
| 709 | const char *guid_to_sha_str(const efi_guid_t *guid); |
| 710 | int algo_to_len(const char *algo); |
| 711 | |
Masahisa Kojima | c961108 | 2022-07-22 11:39:10 +0900 | [diff] [blame] | 712 | int efi_link_dev(efi_handle_t handle, struct udevice *dev); |
Heinrich Schuchardt | 34f3462 | 2022-10-03 09:47:51 +0200 | [diff] [blame] | 713 | int efi_unlink_dev(efi_handle_t handle); |
Masahisa Kojima | 2f407f0 | 2022-12-02 13:59:35 +0900 | [diff] [blame] | 714 | bool efi_varname_is_load_option(u16 *var_name16, int *index); |
Masahisa Kojima | 7ec3c6f | 2022-12-19 11:33:12 +0900 | [diff] [blame] | 715 | efi_status_t efi_next_variable_name(efi_uintn_t *size, u16 **buf, |
| 716 | efi_guid_t *guid); |
Masahisa Kojima | c961108 | 2022-07-22 11:39:10 +0900 | [diff] [blame] | 717 | |
Heinrich Schuchardt | dcdca29 | 2018-11-18 17:58:49 +0100 | [diff] [blame] | 718 | /** |
| 719 | * efi_size_in_pages() - convert size in bytes to size in pages |
| 720 | * |
| 721 | * This macro returns the number of EFI memory pages required to hold 'size' |
| 722 | * bytes. |
| 723 | * |
| 724 | * @size: size in bytes |
| 725 | * Return: size in pages |
| 726 | */ |
Heinrich Schuchardt | aefb0c4 | 2021-01-17 07:52:09 +0100 | [diff] [blame] | 727 | #define efi_size_in_pages(size) (((size) + EFI_PAGE_MASK) >> EFI_PAGE_SHIFT) |
Heinrich Schuchardt | 4564025 | 2023-03-19 09:20:22 +0100 | [diff] [blame] | 728 | /* Allocate boot service data pool memory */ |
| 729 | void *efi_alloc(size_t len); |
Ilias Apalodimas | 6e01c23 | 2021-10-11 15:10:23 +0300 | [diff] [blame] | 730 | /* Allocate pages on the specified alignment */ |
| 731 | void *efi_alloc_aligned_pages(u64 len, int memory_type, size_t align); |
Alexander Graf | 8623f92 | 2016-03-04 01:10:04 +0100 | [diff] [blame] | 732 | /* More specific EFI memory allocator, called by EFI payloads */ |
Heinrich Schuchardt | 9822894 | 2021-08-17 15:05:31 +0200 | [diff] [blame] | 733 | efi_status_t efi_allocate_pages(enum efi_allocate_type type, |
| 734 | enum efi_memory_type memory_type, |
| 735 | efi_uintn_t pages, uint64_t *memory); |
Stefan Brüns | a4f4302 | 2016-10-01 23:32:27 +0200 | [diff] [blame] | 736 | /* EFI memory free function. */ |
Heinrich Schuchardt | 798a441 | 2017-11-06 21:17:48 +0100 | [diff] [blame] | 737 | 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] | 738 | /* EFI memory allocator for small allocations */ |
Heinrich Schuchardt | 9822894 | 2021-08-17 15:05:31 +0200 | [diff] [blame] | 739 | efi_status_t efi_allocate_pool(enum efi_memory_type pool_type, |
| 740 | efi_uintn_t size, void **buffer); |
Stefan Brüns | 67b67d9 | 2016-10-09 22:17:26 +0200 | [diff] [blame] | 741 | /* EFI pool memory free function. */ |
| 742 | efi_status_t efi_free_pool(void *buffer); |
Heinrich Schuchardt | 13ce2d9 | 2023-01-05 18:26:01 +0100 | [diff] [blame] | 743 | /* Allocate and retrieve EFI memory map */ |
| 744 | efi_status_t efi_get_memory_map_alloc(efi_uintn_t *map_size, |
| 745 | struct efi_mem_desc **memory_map); |
Alexander Graf | 8623f92 | 2016-03-04 01:10:04 +0100 | [diff] [blame] | 746 | /* Returns the EFI memory map */ |
Heinrich Schuchardt | 798a441 | 2017-11-06 21:17:48 +0100 | [diff] [blame] | 747 | 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] | 748 | struct efi_mem_desc *memory_map, |
Heinrich Schuchardt | 798a441 | 2017-11-06 21:17:48 +0100 | [diff] [blame] | 749 | efi_uintn_t *map_key, |
| 750 | efi_uintn_t *descriptor_size, |
Alexander Graf | 8623f92 | 2016-03-04 01:10:04 +0100 | [diff] [blame] | 751 | uint32_t *descriptor_version); |
| 752 | /* Adds a range into the EFI memory map */ |
Michael Walle | 282d386 | 2020-05-17 12:29:19 +0200 | [diff] [blame] | 753 | 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] | 754 | /* Adds a conventional range into the EFI memory map */ |
| 755 | efi_status_t efi_add_conventional_memory_map(u64 ram_start, u64 ram_end, |
| 756 | u64 ram_top); |
| 757 | |
Heinrich Schuchardt | 11206f4 | 2018-01-21 19:29:30 +0100 | [diff] [blame] | 758 | /* Called by board init to initialize the EFI drivers */ |
Heinrich Schuchardt | 8f3cc5b | 2018-02-01 12:53:32 +0100 | [diff] [blame] | 759 | efi_status_t efi_driver_init(void); |
Heinrich Schuchardt | da620cf | 2022-10-06 07:29:41 +0200 | [diff] [blame] | 760 | /* Called when a block device is added */ |
| 761 | int efi_disk_probe(void *ctx, struct event *event); |
| 762 | /* Called when a block device is removed */ |
| 763 | int efi_disk_remove(void *ctx, struct event *event); |
Alexander Graf | 8623f92 | 2016-03-04 01:10:04 +0100 | [diff] [blame] | 764 | /* Called by board init to initialize the EFI memory map */ |
| 765 | int efi_memory_init(void); |
Alexander Graf | c5c1163 | 2016-08-19 01:23:24 +0200 | [diff] [blame] | 766 | /* Adds new or overrides configuration table entry to the system table */ |
| 767 | 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] | 768 | /* Sets up a loaded image */ |
Heinrich Schuchardt | 3c3a735 | 2018-09-23 17:21:51 +0200 | [diff] [blame] | 769 | efi_status_t efi_setup_loaded_image(struct efi_device_path *device_path, |
| 770 | struct efi_device_path *file_path, |
| 771 | struct efi_loaded_image_obj **handle_ptr, |
| 772 | struct efi_loaded_image **info_ptr); |
Alexander Graf | 8623f92 | 2016-03-04 01:10:04 +0100 | [diff] [blame] | 773 | |
Alexander Graf | 7c00a3c | 2016-05-11 18:25:48 +0200 | [diff] [blame] | 774 | #ifdef CONFIG_EFI_LOADER_BOUNCE_BUFFER |
| 775 | extern void *efi_bounce_buffer; |
| 776 | #define EFI_LOADER_BOUNCE_BUFFER_SIZE (64 * 1024 * 1024) |
| 777 | #endif |
| 778 | |
Heinrich Schuchardt | 24f0e6a | 2022-02-26 12:10:10 +0100 | [diff] [blame] | 779 | /* shorten device path */ |
| 780 | struct efi_device_path *efi_dp_shorten(struct efi_device_path *dp); |
Rob Clark | f90cb9f | 2017-09-13 18:05:28 -0400 | [diff] [blame] | 781 | 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] | 782 | int efi_dp_match(const struct efi_device_path *a, |
| 783 | const struct efi_device_path *b); |
Heinrich Schuchardt | ad6d5a4 | 2022-03-04 08:20:00 +0100 | [diff] [blame] | 784 | efi_handle_t efi_dp_find_obj(struct efi_device_path *dp, |
Heinrich Schuchardt | 0a04a41 | 2022-03-19 06:35:43 +0100 | [diff] [blame] | 785 | const efi_guid_t *guid, |
Heinrich Schuchardt | ad6d5a4 | 2022-03-04 08:20:00 +0100 | [diff] [blame] | 786 | struct efi_device_path **rem); |
Heinrich Schuchardt | 51ca4f5 | 2018-04-16 07:59:08 +0200 | [diff] [blame] | 787 | /* get size of the first device path instance excluding end node */ |
| 788 | efi_uintn_t efi_dp_instance_size(const struct efi_device_path *dp); |
| 789 | /* size of multi-instance device path excluding end node */ |
| 790 | efi_uintn_t efi_dp_size(const struct efi_device_path *dp); |
Rob Clark | f90cb9f | 2017-09-13 18:05:28 -0400 | [diff] [blame] | 791 | struct efi_device_path *efi_dp_dup(const struct efi_device_path *dp); |
| 792 | struct efi_device_path *efi_dp_append(const struct efi_device_path *dp1, |
| 793 | const struct efi_device_path *dp2); |
| 794 | struct efi_device_path *efi_dp_append_node(const struct efi_device_path *dp, |
| 795 | const struct efi_device_path *node); |
Heinrich Schuchardt | b41c8e2 | 2018-04-16 07:59:05 +0200 | [diff] [blame] | 796 | /* Create a device path node of given type, sub-type, length */ |
| 797 | struct efi_device_path *efi_dp_create_device_node(const u8 type, |
| 798 | const u8 sub_type, |
| 799 | const u16 length); |
Heinrich Schuchardt | cb0f7ce | 2018-04-16 07:59:09 +0200 | [diff] [blame] | 800 | /* Append device path instance */ |
| 801 | struct efi_device_path *efi_dp_append_instance( |
| 802 | const struct efi_device_path *dp, |
| 803 | const struct efi_device_path *dpi); |
| 804 | /* Get next device path instance */ |
| 805 | struct efi_device_path *efi_dp_get_next_instance(struct efi_device_path **dp, |
| 806 | efi_uintn_t *size); |
| 807 | /* Check if a device path contains muliple instances */ |
| 808 | bool efi_dp_is_multi_instance(const struct efi_device_path *dp); |
Rob Clark | f90cb9f | 2017-09-13 18:05:28 -0400 | [diff] [blame] | 809 | |
Rob Clark | f90cb9f | 2017-09-13 18:05:28 -0400 | [diff] [blame] | 810 | 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] | 811 | /* Create a device node for a block device partition. */ |
| 812 | 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] | 813 | struct efi_device_path *efi_dp_from_file(struct blk_desc *desc, int part, |
| 814 | const char *path); |
| 815 | struct efi_device_path *efi_dp_from_eth(void); |
Rob Clark | 18ceba7 | 2017-10-10 08:23:06 -0400 | [diff] [blame] | 816 | struct efi_device_path *efi_dp_from_mem(uint32_t mem_type, |
| 817 | uint64_t start_address, |
| 818 | uint64_t end_address); |
Heinrich Schuchardt | 0976f8b | 2018-01-19 20:24:49 +0100 | [diff] [blame] | 819 | /* Determine the last device path node that is not the end node. */ |
| 820 | const struct efi_device_path *efi_dp_last_node( |
| 821 | const struct efi_device_path *dp); |
Heinrich Schuchardt | 468bf97 | 2018-01-19 20:24:37 +0100 | [diff] [blame] | 822 | efi_status_t efi_dp_split_file_path(struct efi_device_path *full_path, |
| 823 | struct efi_device_path **device_path, |
| 824 | struct efi_device_path **file_path); |
Heinrich Schuchardt | 81244ea | 2022-02-04 20:47:09 +0100 | [diff] [blame] | 825 | struct efi_device_path *efi_dp_from_uart(void); |
AKASHI Takahiro | 035fb01 | 2018-10-17 16:32:03 +0900 | [diff] [blame] | 826 | efi_status_t efi_dp_from_name(const char *dev, const char *devnr, |
| 827 | const char *path, |
| 828 | struct efi_device_path **device, |
| 829 | struct efi_device_path **file); |
Heinrich Schuchardt | 22c8e08 | 2020-08-23 10:49:46 +0200 | [diff] [blame] | 830 | ssize_t efi_dp_check_length(const struct efi_device_path *dp, |
| 831 | const size_t maxlen); |
Rob Clark | f90cb9f | 2017-09-13 18:05:28 -0400 | [diff] [blame] | 832 | |
| 833 | #define EFI_DP_TYPE(_dp, _type, _subtype) \ |
| 834 | (((_dp)->type == DEVICE_PATH_TYPE_##_type) && \ |
| 835 | ((_dp)->sub_type == DEVICE_PATH_SUB_TYPE_##_subtype)) |
| 836 | |
Masahisa Kojima | 97bd9da | 2022-06-19 13:55:59 +0900 | [diff] [blame] | 837 | /* template END node: */ |
| 838 | extern const struct efi_device_path END; |
| 839 | |
AKASHI Takahiro | 3240184 | 2019-06-05 13:21:38 +0900 | [diff] [blame] | 840 | /* Indicate supported runtime services */ |
| 841 | efi_status_t efi_init_runtime_supported(void); |
| 842 | |
Heinrich Schuchardt | 69c1576 | 2018-07-29 09:49:04 +0200 | [diff] [blame] | 843 | /* Update CRC32 in table header */ |
| 844 | void __efi_runtime efi_update_table_header_crc32(struct efi_table_hdr *table); |
| 845 | |
Alexander Graf | 7725609 | 2016-08-16 21:08:45 +0200 | [diff] [blame] | 846 | /* Boards may provide the functions below to implement RTS functionality */ |
| 847 | |
Alexander Graf | 393dd91 | 2016-10-14 13:45:30 +0200 | [diff] [blame] | 848 | void __efi_runtime EFIAPI efi_reset_system( |
Alexander Graf | 7725609 | 2016-08-16 21:08:45 +0200 | [diff] [blame] | 849 | enum efi_reset_type reset_type, |
| 850 | efi_status_t reset_status, |
| 851 | unsigned long data_size, void *reset_data); |
Heinrich Schuchardt | 099b3b7 | 2018-03-03 15:28:59 +0100 | [diff] [blame] | 852 | |
| 853 | /* Architecture specific initialization of the EFI subsystem */ |
| 854 | efi_status_t efi_reset_system_init(void); |
Alexander Graf | 7725609 | 2016-08-16 21:08:45 +0200 | [diff] [blame] | 855 | |
Alexander Graf | 393dd91 | 2016-10-14 13:45:30 +0200 | [diff] [blame] | 856 | efi_status_t __efi_runtime EFIAPI efi_get_time( |
Alexander Graf | 7725609 | 2016-08-16 21:08:45 +0200 | [diff] [blame] | 857 | struct efi_time *time, |
| 858 | struct efi_time_cap *capabilities); |
Alexander Graf | 7725609 | 2016-08-16 21:08:45 +0200 | [diff] [blame] | 859 | |
Heinrich Schuchardt | 289121e | 2019-05-31 07:38:29 +0200 | [diff] [blame] | 860 | efi_status_t __efi_runtime EFIAPI efi_set_time(struct efi_time *time); |
| 861 | |
Heinrich Schuchardt | d33ae3e | 2017-09-15 10:06:11 +0200 | [diff] [blame] | 862 | #ifdef CONFIG_CMD_BOOTEFI_SELFTEST |
| 863 | /* |
| 864 | * Entry point for the tests of the EFI API. |
| 865 | * It is called by 'bootefi selftest' |
| 866 | */ |
| 867 | efi_status_t EFIAPI efi_selftest(efi_handle_t image_handle, |
| 868 | struct efi_system_table *systab); |
| 869 | #endif |
| 870 | |
Heinrich Schuchardt | e06ae19 | 2018-12-30 20:53:51 +0100 | [diff] [blame] | 871 | efi_status_t EFIAPI efi_get_variable(u16 *variable_name, |
| 872 | const efi_guid_t *vendor, u32 *attributes, |
| 873 | efi_uintn_t *data_size, void *data); |
Heinrich Schuchardt | d6a6baa | 2018-05-17 07:57:05 +0200 | [diff] [blame] | 874 | efi_status_t EFIAPI efi_get_next_variable_name(efi_uintn_t *variable_name_size, |
| 875 | u16 *variable_name, |
Heinrich Schuchardt | 82cd6c4 | 2020-03-22 18:28:20 +0100 | [diff] [blame] | 876 | efi_guid_t *vendor); |
Heinrich Schuchardt | e06ae19 | 2018-12-30 20:53:51 +0100 | [diff] [blame] | 877 | efi_status_t EFIAPI efi_set_variable(u16 *variable_name, |
| 878 | const efi_guid_t *vendor, u32 attributes, |
Heinrich Schuchardt | 73e2ab0 | 2018-12-30 21:03:15 +0100 | [diff] [blame] | 879 | efi_uintn_t data_size, const void *data); |
Rob Clark | 15f3d74 | 2017-09-13 18:05:37 -0400 | [diff] [blame] | 880 | |
Heinrich Schuchardt | 9b19dae | 2019-06-20 12:13:05 +0200 | [diff] [blame] | 881 | efi_status_t EFIAPI efi_query_variable_info( |
| 882 | u32 attributes, u64 *maximum_variable_storage_size, |
| 883 | u64 *remaining_variable_storage_size, |
| 884 | u64 *maximum_variable_size); |
| 885 | |
Heinrich Schuchardt | 1ad2f0d | 2021-09-09 07:12:14 +0200 | [diff] [blame] | 886 | void *efi_get_var(const u16 *name, const efi_guid_t *vendor, efi_uintn_t *size); |
Ilias Apalodimas | aa0f755 | 2021-03-17 21:54:59 +0200 | [diff] [blame] | 887 | |
AKASHI Takahiro | bd23774 | 2018-11-05 18:06:41 +0900 | [diff] [blame] | 888 | /* |
| 889 | * See section 3.1.3 in the v2.7 UEFI spec for more details on |
| 890 | * the layout of EFI_LOAD_OPTION. In short it is: |
| 891 | * |
| 892 | * typedef struct _EFI_LOAD_OPTION { |
| 893 | * UINT32 Attributes; |
| 894 | * UINT16 FilePathListLength; |
| 895 | * // CHAR16 Description[]; <-- variable length, NULL terminated |
| 896 | * // EFI_DEVICE_PATH_PROTOCOL FilePathList[]; |
| 897 | * <-- FilePathListLength bytes |
| 898 | * // UINT8 OptionalData[]; |
| 899 | * } EFI_LOAD_OPTION; |
| 900 | */ |
| 901 | struct efi_load_option { |
| 902 | u32 attributes; |
| 903 | u16 file_path_length; |
| 904 | u16 *label; |
| 905 | struct efi_device_path *file_path; |
Heinrich Schuchardt | 9df002e | 2019-04-29 13:51:45 +0200 | [diff] [blame] | 906 | const u8 *optional_data; |
AKASHI Takahiro | bd23774 | 2018-11-05 18:06:41 +0900 | [diff] [blame] | 907 | }; |
| 908 | |
Ilias Apalodimas | 483d28e | 2021-03-17 21:54:58 +0200 | [diff] [blame] | 909 | struct efi_device_path *efi_dp_from_lo(struct efi_load_option *lo, |
Heinrich Schuchardt | 9979cff | 2021-10-15 01:31:02 +0200 | [diff] [blame] | 910 | const efi_guid_t *guid); |
Ilias Apalodimas | 483d28e | 2021-03-17 21:54:58 +0200 | [diff] [blame] | 911 | struct efi_device_path *efi_dp_concat(const struct efi_device_path *dp1, |
| 912 | const struct efi_device_path *dp2); |
Masahisa Kojima | 6460c3e | 2021-10-26 17:27:25 +0900 | [diff] [blame] | 913 | struct efi_device_path *search_gpt_dp_node(struct efi_device_path *device_path); |
Heinrich Schuchardt | 7ca84f8 | 2020-05-31 22:46:09 +0200 | [diff] [blame] | 914 | efi_status_t efi_deserialize_load_option(struct efi_load_option *lo, u8 *data, |
| 915 | efi_uintn_t *size); |
AKASHI Takahiro | bd23774 | 2018-11-05 18:06:41 +0900 | [diff] [blame] | 916 | unsigned long efi_serialize_load_option(struct efi_load_option *lo, u8 **data); |
Heinrich Schuchardt | 25c6be5 | 2020-08-07 17:47:13 +0200 | [diff] [blame] | 917 | efi_status_t efi_set_load_options(efi_handle_t handle, |
| 918 | efi_uintn_t load_options_size, |
| 919 | void *load_options); |
Heinrich Schuchardt | a7647a7 | 2020-08-07 17:49:39 +0200 | [diff] [blame] | 920 | efi_status_t efi_bootmgr_load(efi_handle_t *handle, void **load_options); |
Rob Clark | c84c110 | 2017-09-13 18:05:38 -0400 | [diff] [blame] | 921 | |
AKASHI Takahiro | 1faaca4 | 2020-04-14 11:51:39 +0900 | [diff] [blame] | 922 | /** |
Heinrich Schuchardt | 6eb30c1 | 2021-02-25 08:02:37 +0100 | [diff] [blame] | 923 | * struct efi_image_regions - A list of memory regions |
AKASHI Takahiro | 1faaca4 | 2020-04-14 11:51:39 +0900 | [diff] [blame] | 924 | * |
| 925 | * @max: Maximum number of regions |
| 926 | * @num: Number of regions |
| 927 | * @reg: array of regions |
| 928 | */ |
| 929 | struct efi_image_regions { |
| 930 | int max; |
| 931 | int num; |
| 932 | struct image_region reg[]; |
| 933 | }; |
| 934 | |
| 935 | /** |
Heinrich Schuchardt | 6eb30c1 | 2021-02-25 08:02:37 +0100 | [diff] [blame] | 936 | * struct efi_sig_data - A decoded data of struct efi_signature_data |
AKASHI Takahiro | 1faaca4 | 2020-04-14 11:51:39 +0900 | [diff] [blame] | 937 | * |
| 938 | * This structure represents an internal form of signature in |
| 939 | * signature database. A listed list may represent a signature list. |
| 940 | * |
| 941 | * @next: Pointer to next entry |
Heinrich Schuchardt | 6eb30c1 | 2021-02-25 08:02:37 +0100 | [diff] [blame] | 942 | * @owner: Signature owner |
AKASHI Takahiro | 1faaca4 | 2020-04-14 11:51:39 +0900 | [diff] [blame] | 943 | * @data: Pointer to signature data |
| 944 | * @size: Size of signature data |
| 945 | */ |
| 946 | struct efi_sig_data { |
| 947 | struct efi_sig_data *next; |
| 948 | efi_guid_t owner; |
| 949 | void *data; |
| 950 | size_t size; |
| 951 | }; |
| 952 | |
| 953 | /** |
Heinrich Schuchardt | 6eb30c1 | 2021-02-25 08:02:37 +0100 | [diff] [blame] | 954 | * struct efi_signature_store - A decoded data of signature database |
AKASHI Takahiro | 1faaca4 | 2020-04-14 11:51:39 +0900 | [diff] [blame] | 955 | * |
| 956 | * This structure represents an internal form of signature database. |
| 957 | * |
| 958 | * @next: Pointer to next entry |
| 959 | * @sig_type: Signature type |
| 960 | * @sig_data_list: Pointer to signature list |
| 961 | */ |
| 962 | struct efi_signature_store { |
| 963 | struct efi_signature_store *next; |
| 964 | efi_guid_t sig_type; |
| 965 | struct efi_sig_data *sig_data_list; |
| 966 | }; |
| 967 | |
| 968 | struct x509_certificate; |
| 969 | struct pkcs7_message; |
| 970 | |
Masahisa Kojima | 767a9e6 | 2022-09-12 17:33:54 +0900 | [diff] [blame] | 971 | /** |
| 972 | * struct eficonfig_media_boot_option - boot option for (removable) media device |
| 973 | * |
| 974 | * This structure is used to enumerate possible boot option |
| 975 | * |
| 976 | * @lo: Serialized load option data |
| 977 | * @size: Size of serialized load option data |
| 978 | * @exist: Flag to indicate the load option already exists |
| 979 | * in Non-volatile load option |
| 980 | */ |
| 981 | struct eficonfig_media_boot_option { |
| 982 | void *lo; |
| 983 | efi_uintn_t size; |
| 984 | bool exist; |
| 985 | }; |
| 986 | |
AKASHI Takahiro | f47b9b3 | 2022-07-05 14:48:12 +0900 | [diff] [blame] | 987 | bool efi_hash_regions(struct image_region *regs, int count, |
| 988 | void **hash, const char *hash_algo, int *len); |
AKASHI Takahiro | de92407 | 2020-07-08 14:01:57 +0900 | [diff] [blame] | 989 | bool efi_signature_lookup_digest(struct efi_image_regions *regs, |
Ilias Apalodimas | 71eae98 | 2022-01-29 00:20:31 +0200 | [diff] [blame] | 990 | struct efi_signature_store *db, |
| 991 | bool dbx); |
AKASHI Takahiro | 14afd06 | 2020-07-21 19:35:22 +0900 | [diff] [blame] | 992 | bool efi_signature_verify(struct efi_image_regions *regs, |
| 993 | struct pkcs7_message *msg, |
| 994 | struct efi_signature_store *db, |
| 995 | struct efi_signature_store *dbx); |
AKASHI Takahiro | 1641180 | 2020-08-14 14:39:23 +0900 | [diff] [blame] | 996 | static inline bool efi_signature_verify_one(struct efi_image_regions *regs, |
| 997 | struct pkcs7_message *msg, |
| 998 | struct efi_signature_store *db) |
| 999 | { |
| 1000 | return efi_signature_verify(regs, msg, db, NULL); |
| 1001 | } |
AKASHI Takahiro | 4154b64 | 2020-07-08 14:01:56 +0900 | [diff] [blame] | 1002 | bool efi_signature_check_signers(struct pkcs7_message *msg, |
| 1003 | struct efi_signature_store *dbx); |
AKASHI Takahiro | 1faaca4 | 2020-04-14 11:51:39 +0900 | [diff] [blame] | 1004 | |
| 1005 | efi_status_t efi_image_region_add(struct efi_image_regions *regs, |
| 1006 | const void *start, const void *end, |
| 1007 | int nocheck); |
AKASHI Takahiro | d2cefc8 | 2020-04-14 11:51:40 +0900 | [diff] [blame] | 1008 | |
| 1009 | void efi_sigstore_free(struct efi_signature_store *sigstore); |
Sughosh Ganu | fa0faa6 | 2020-12-30 19:27:08 +0530 | [diff] [blame] | 1010 | struct efi_signature_store *efi_build_signature_store(void *sig_list, |
| 1011 | efi_uintn_t size); |
AKASHI Takahiro | d2cefc8 | 2020-04-14 11:51:40 +0900 | [diff] [blame] | 1012 | struct efi_signature_store *efi_sigstore_parse_sigdb(u16 *name); |
AKASHI Takahiro | b0f49ee | 2020-04-14 11:51:41 +0900 | [diff] [blame] | 1013 | |
| 1014 | bool efi_secure_boot_enabled(void); |
AKASHI Takahiro | 0e104e3 | 2020-04-14 11:51:44 +0900 | [diff] [blame] | 1015 | |
Sughosh Ganu | 586bb98 | 2020-12-30 19:27:09 +0530 | [diff] [blame] | 1016 | bool efi_capsule_auth_enabled(void); |
| 1017 | |
Masahisa Kojima | 70be5a6 | 2021-05-26 12:09:58 +0900 | [diff] [blame] | 1018 | void *efi_prepare_aligned_image(void *efi, u64 *efi_size); |
| 1019 | |
AKASHI Takahiro | 0e104e3 | 2020-04-14 11:51:44 +0900 | [diff] [blame] | 1020 | bool efi_image_parse(void *efi, size_t len, struct efi_image_regions **regp, |
| 1021 | WIN_CERTIFICATE **auth, size_t *auth_len); |
AKASHI Takahiro | 1faaca4 | 2020-04-14 11:51:39 +0900 | [diff] [blame] | 1022 | |
Sughosh Ganu | ea35008 | 2020-12-30 19:27:07 +0530 | [diff] [blame] | 1023 | struct pkcs7_message *efi_parse_pkcs7_header(const void *buf, |
| 1024 | size_t buflen, |
| 1025 | u8 **tmpbuf); |
| 1026 | |
Heinrich Schuchardt | 8cd9975 | 2020-06-28 16:30:29 +0200 | [diff] [blame] | 1027 | /* runtime implementation of memcpy() */ |
| 1028 | void efi_memcpy_runtime(void *dest, const void *src, size_t n); |
| 1029 | |
Paul Barker | 8acc3d9 | 2022-10-05 13:18:35 +0100 | [diff] [blame] | 1030 | /* commonly used helper functions */ |
Ilias Apalodimas | 2157529 | 2020-12-31 12:26:46 +0200 | [diff] [blame] | 1031 | u16 *efi_create_indexed_name(u16 *buffer, size_t buffer_size, const char *name, |
| 1032 | unsigned int index); |
Paul Barker | 8acc3d9 | 2022-10-05 13:18:35 +0100 | [diff] [blame] | 1033 | efi_string_t efi_convert_string(const char *str); |
AKASHI Takahiro | 9407468 | 2020-10-29 13:47:46 +0900 | [diff] [blame] | 1034 | |
AKASHI Takahiro | f4818e6 | 2020-11-30 18:12:12 +0900 | [diff] [blame] | 1035 | extern const struct efi_firmware_management_protocol efi_fmp_fit; |
AKASHI Takahiro | 7ff3f3c | 2020-11-17 09:28:00 +0900 | [diff] [blame] | 1036 | extern const struct efi_firmware_management_protocol efi_fmp_raw; |
AKASHI Takahiro | f4818e6 | 2020-11-30 18:12:12 +0900 | [diff] [blame] | 1037 | |
AKASHI Takahiro | 473d9b3 | 2020-11-17 09:27:55 +0900 | [diff] [blame] | 1038 | /* Capsule update */ |
| 1039 | efi_status_t EFIAPI efi_update_capsule( |
| 1040 | struct efi_capsule_header **capsule_header_array, |
| 1041 | efi_uintn_t capsule_count, |
| 1042 | u64 scatter_gather_list); |
| 1043 | efi_status_t EFIAPI efi_query_capsule_caps( |
| 1044 | struct efi_capsule_header **capsule_header_array, |
| 1045 | efi_uintn_t capsule_count, |
| 1046 | u64 *maximum_capsule_size, |
| 1047 | u32 *reset_type); |
| 1048 | |
Sughosh Ganu | 586bb98 | 2020-12-30 19:27:09 +0530 | [diff] [blame] | 1049 | efi_status_t efi_capsule_authenticate(const void *capsule, |
| 1050 | efi_uintn_t capsule_size, |
| 1051 | void **image, efi_uintn_t *image_size); |
| 1052 | |
Simon Glass | 9097537 | 2022-01-23 12:55:12 -0700 | [diff] [blame] | 1053 | #define EFI_CAPSULE_DIR u"\\EFI\\UpdateCapsule\\" |
AKASHI Takahiro | 45b81954 | 2020-11-17 09:27:56 +0900 | [diff] [blame] | 1054 | |
Jose Marinho | ebb61ee | 2021-03-02 17:26:38 +0000 | [diff] [blame] | 1055 | /** |
Sughosh Ganu | ccb3646 | 2022-04-15 11:29:34 +0530 | [diff] [blame] | 1056 | * struct efi_fw_image - Information on firmware images updatable through |
| 1057 | * capsule update |
| 1058 | * |
| 1059 | * This structure gives information about the firmware images on the platform |
| 1060 | * which can be updated through the capsule update mechanism |
| 1061 | * |
| 1062 | * @image_type_id: Image GUID. Same value is to be used in the capsule |
| 1063 | * @fw_name: Name of the firmware image |
| 1064 | * @image_index: Image Index, same as value passed to SetImage FMP |
| 1065 | * function |
| 1066 | */ |
| 1067 | struct efi_fw_image { |
| 1068 | efi_guid_t image_type_id; |
| 1069 | u16 *fw_name; |
| 1070 | u8 image_index; |
| 1071 | }; |
| 1072 | |
| 1073 | /** |
| 1074 | * struct efi_capsule_update_info - Information needed for capsule updates |
| 1075 | * |
| 1076 | * This structure provides information needed for performing firmware |
| 1077 | * updates. The structure needs to be initialised per platform, for all |
| 1078 | * platforms which enable capsule updates |
| 1079 | * |
| 1080 | * @dfu_string: String used to populate dfu_alt_info |
| 1081 | * @images: Pointer to an array of updatable images |
| 1082 | */ |
| 1083 | struct efi_capsule_update_info { |
| 1084 | const char *dfu_string; |
| 1085 | struct efi_fw_image *images; |
| 1086 | }; |
| 1087 | |
| 1088 | extern struct efi_capsule_update_info update_info; |
| 1089 | extern u8 num_image_type_guids; |
| 1090 | |
| 1091 | /** |
Jose Marinho | ebb61ee | 2021-03-02 17:26:38 +0000 | [diff] [blame] | 1092 | * Install the ESRT system table. |
| 1093 | * |
Heinrich Schuchardt | 47b4c02 | 2022-01-19 18:05:50 +0100 | [diff] [blame] | 1094 | * Return: status code |
Jose Marinho | ebb61ee | 2021-03-02 17:26:38 +0000 | [diff] [blame] | 1095 | */ |
| 1096 | efi_status_t efi_esrt_register(void); |
| 1097 | |
| 1098 | /** |
Jose Marinho | ff72cb3 | 2021-12-23 14:51:07 +0000 | [diff] [blame] | 1099 | * efi_ecpt_register() - Install the ECPT system table. |
| 1100 | * |
| 1101 | * Return: status code |
| 1102 | */ |
| 1103 | efi_status_t efi_ecpt_register(void); |
| 1104 | |
| 1105 | /** |
Jose Marinho | ebb61ee | 2021-03-02 17:26:38 +0000 | [diff] [blame] | 1106 | * efi_esrt_populate() - Populates the ESRT entries from the FMP instances |
| 1107 | * present in the system. |
| 1108 | * If an ESRT already exists, the old ESRT is replaced in the system table. |
| 1109 | * The memory of the old ESRT is deallocated. |
| 1110 | * |
| 1111 | * Return: |
| 1112 | * - EFI_SUCCESS if the ESRT is correctly created |
| 1113 | * - error code otherwise. |
| 1114 | */ |
| 1115 | efi_status_t efi_esrt_populate(void); |
Ilias Apalodimas | fac773e | 2021-06-22 17:38:53 +0300 | [diff] [blame] | 1116 | efi_status_t efi_load_capsule_drivers(void); |
Ruchika Gupta | bc9495c | 2021-11-29 13:09:44 +0530 | [diff] [blame] | 1117 | |
| 1118 | efi_status_t platform_get_eventlog(struct udevice *dev, u64 *addr, u32 *sz); |
Masahisa Kojima | c5ff0a0 | 2022-09-12 17:33:50 +0900 | [diff] [blame] | 1119 | |
| 1120 | efi_status_t efi_locate_handle_buffer_int(enum efi_locate_search_type search_type, |
| 1121 | const efi_guid_t *protocol, void *search_key, |
| 1122 | efi_uintn_t *no_handles, efi_handle_t **buffer); |
| 1123 | |
| 1124 | efi_status_t efi_open_volume_int(struct efi_simple_file_system_protocol *this, |
| 1125 | struct efi_file_handle **root); |
| 1126 | efi_status_t efi_file_open_int(struct efi_file_handle *this, |
| 1127 | struct efi_file_handle **new_handle, |
| 1128 | u16 *file_name, u64 open_mode, |
| 1129 | u64 attributes); |
| 1130 | efi_status_t efi_file_close_int(struct efi_file_handle *file); |
| 1131 | efi_status_t efi_file_read_int(struct efi_file_handle *this, |
| 1132 | efi_uintn_t *buffer_size, void *buffer); |
| 1133 | efi_status_t efi_file_setpos_int(struct efi_file_handle *file, u64 pos); |
| 1134 | |
| 1135 | typedef efi_status_t (*efi_console_filter_func)(struct efi_input_key *key); |
| 1136 | efi_status_t efi_console_get_u16_string |
| 1137 | (struct efi_simple_text_input_protocol *cin, |
| 1138 | u16 *buf, efi_uintn_t count, efi_console_filter_func filer_func, |
| 1139 | int row, int col); |
| 1140 | |
| 1141 | efi_status_t efi_disk_get_device_name(const efi_handle_t handle, char *buf, int size); |
| 1142 | |
Heinrich Schuchardt | 8600f99 | 2023-02-10 09:01:13 +0100 | [diff] [blame] | 1143 | /** |
| 1144 | * efi_add_known_memory() - add memory banks to EFI memory map |
| 1145 | * |
| 1146 | * This weak function may be overridden for specific architectures. |
| 1147 | */ |
| 1148 | void efi_add_known_memory(void); |
| 1149 | |
Heinrich Schuchardt | c2fd477 | 2017-10-18 18:13:07 +0200 | [diff] [blame] | 1150 | #endif /* _EFI_LOADER_H */ |