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