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