Line data Source code
1 : /* SPDX-License-Identifier: GPL-2.0 */
2 : #ifndef _LINUX_EFI_H
3 : #define _LINUX_EFI_H
4 :
5 : /*
6 : * Extensible Firmware Interface
7 : * Based on 'Extensible Firmware Interface Specification' version 0.9, April 30, 1999
8 : *
9 : * Copyright (C) 1999 VA Linux Systems
10 : * Copyright (C) 1999 Walt Drummond <drummond@valinux.com>
11 : * Copyright (C) 1999, 2002-2003 Hewlett-Packard Co.
12 : * David Mosberger-Tang <davidm@hpl.hp.com>
13 : * Stephane Eranian <eranian@hpl.hp.com>
14 : */
15 : #include <linux/init.h>
16 : #include <linux/string.h>
17 : #include <linux/time.h>
18 : #include <linux/types.h>
19 : #include <linux/proc_fs.h>
20 : #include <linux/rtc.h>
21 : #include <linux/ioport.h>
22 : #include <linux/pfn.h>
23 : #include <linux/pstore.h>
24 : #include <linux/range.h>
25 : #include <linux/reboot.h>
26 : #include <linux/uuid.h>
27 : #include <linux/screen_info.h>
28 :
29 : #include <asm/page.h>
30 :
31 : #define EFI_SUCCESS 0
32 : #define EFI_LOAD_ERROR ( 1 | (1UL << (BITS_PER_LONG-1)))
33 : #define EFI_INVALID_PARAMETER ( 2 | (1UL << (BITS_PER_LONG-1)))
34 : #define EFI_UNSUPPORTED ( 3 | (1UL << (BITS_PER_LONG-1)))
35 : #define EFI_BAD_BUFFER_SIZE ( 4 | (1UL << (BITS_PER_LONG-1)))
36 : #define EFI_BUFFER_TOO_SMALL ( 5 | (1UL << (BITS_PER_LONG-1)))
37 : #define EFI_NOT_READY ( 6 | (1UL << (BITS_PER_LONG-1)))
38 : #define EFI_DEVICE_ERROR ( 7 | (1UL << (BITS_PER_LONG-1)))
39 : #define EFI_WRITE_PROTECTED ( 8 | (1UL << (BITS_PER_LONG-1)))
40 : #define EFI_OUT_OF_RESOURCES ( 9 | (1UL << (BITS_PER_LONG-1)))
41 : #define EFI_NOT_FOUND (14 | (1UL << (BITS_PER_LONG-1)))
42 : #define EFI_TIMEOUT (18 | (1UL << (BITS_PER_LONG-1)))
43 : #define EFI_ABORTED (21 | (1UL << (BITS_PER_LONG-1)))
44 : #define EFI_SECURITY_VIOLATION (26 | (1UL << (BITS_PER_LONG-1)))
45 :
46 : typedef unsigned long efi_status_t;
47 : typedef u8 efi_bool_t;
48 : typedef u16 efi_char16_t; /* UNICODE character */
49 : typedef u64 efi_physical_addr_t;
50 : typedef void *efi_handle_t;
51 :
52 : #if defined(CONFIG_X86_64)
53 : #define __efiapi __attribute__((ms_abi))
54 : #elif defined(CONFIG_X86_32)
55 : #define __efiapi __attribute__((regparm(0)))
56 : #else
57 : #define __efiapi
58 : #endif
59 :
60 : /*
61 : * The UEFI spec and EDK2 reference implementation both define EFI_GUID as
62 : * struct { u32 a; u16; b; u16 c; u8 d[8]; }; and so the implied alignment
63 : * is 32 bits not 8 bits like our guid_t. In some cases (i.e., on 32-bit ARM),
64 : * this means that firmware services invoked by the kernel may assume that
65 : * efi_guid_t* arguments are 32-bit aligned, and use memory accessors that
66 : * do not tolerate misalignment. So let's set the minimum alignment to 32 bits.
67 : *
68 : * Note that the UEFI spec as well as some comments in the EDK2 code base
69 : * suggest that EFI_GUID should be 64-bit aligned, but this appears to be
70 : * a mistake, given that no code seems to exist that actually enforces that
71 : * or relies on it.
72 : */
73 : typedef guid_t efi_guid_t __aligned(__alignof__(u32));
74 :
75 : #define EFI_GUID(a,b,c,d0,d1,d2,d3,d4,d5,d6,d7) \
76 : GUID_INIT(a, b, c, d0, d1, d2, d3, d4, d5, d6, d7)
77 :
78 : /*
79 : * Generic EFI table header
80 : */
81 : typedef struct {
82 : u64 signature;
83 : u32 revision;
84 : u32 headersize;
85 : u32 crc32;
86 : u32 reserved;
87 : } efi_table_hdr_t;
88 :
89 : /*
90 : * Memory map descriptor:
91 : */
92 :
93 : /* Memory types: */
94 : #define EFI_RESERVED_TYPE 0
95 : #define EFI_LOADER_CODE 1
96 : #define EFI_LOADER_DATA 2
97 : #define EFI_BOOT_SERVICES_CODE 3
98 : #define EFI_BOOT_SERVICES_DATA 4
99 : #define EFI_RUNTIME_SERVICES_CODE 5
100 : #define EFI_RUNTIME_SERVICES_DATA 6
101 : #define EFI_CONVENTIONAL_MEMORY 7
102 : #define EFI_UNUSABLE_MEMORY 8
103 : #define EFI_ACPI_RECLAIM_MEMORY 9
104 : #define EFI_ACPI_MEMORY_NVS 10
105 : #define EFI_MEMORY_MAPPED_IO 11
106 : #define EFI_MEMORY_MAPPED_IO_PORT_SPACE 12
107 : #define EFI_PAL_CODE 13
108 : #define EFI_PERSISTENT_MEMORY 14
109 : #define EFI_MAX_MEMORY_TYPE 15
110 :
111 : /* Attribute values: */
112 : #define EFI_MEMORY_UC ((u64)0x0000000000000001ULL) /* uncached */
113 : #define EFI_MEMORY_WC ((u64)0x0000000000000002ULL) /* write-coalescing */
114 : #define EFI_MEMORY_WT ((u64)0x0000000000000004ULL) /* write-through */
115 : #define EFI_MEMORY_WB ((u64)0x0000000000000008ULL) /* write-back */
116 : #define EFI_MEMORY_UCE ((u64)0x0000000000000010ULL) /* uncached, exported */
117 : #define EFI_MEMORY_WP ((u64)0x0000000000001000ULL) /* write-protect */
118 : #define EFI_MEMORY_RP ((u64)0x0000000000002000ULL) /* read-protect */
119 : #define EFI_MEMORY_XP ((u64)0x0000000000004000ULL) /* execute-protect */
120 : #define EFI_MEMORY_NV ((u64)0x0000000000008000ULL) /* non-volatile */
121 : #define EFI_MEMORY_MORE_RELIABLE \
122 : ((u64)0x0000000000010000ULL) /* higher reliability */
123 : #define EFI_MEMORY_RO ((u64)0x0000000000020000ULL) /* read-only */
124 : #define EFI_MEMORY_SP ((u64)0x0000000000040000ULL) /* soft reserved */
125 : #define EFI_MEMORY_CPU_CRYPTO ((u64)0x0000000000080000ULL) /* supports encryption */
126 : #define EFI_MEMORY_RUNTIME ((u64)0x8000000000000000ULL) /* range requires runtime mapping */
127 : #define EFI_MEMORY_DESCRIPTOR_VERSION 1
128 :
129 : #define EFI_PAGE_SHIFT 12
130 : #define EFI_PAGE_SIZE (1UL << EFI_PAGE_SHIFT)
131 : #define EFI_PAGES_MAX (U64_MAX >> EFI_PAGE_SHIFT)
132 :
133 : typedef struct {
134 : u32 type;
135 : u32 pad;
136 : u64 phys_addr;
137 : u64 virt_addr;
138 : u64 num_pages;
139 : u64 attribute;
140 : } efi_memory_desc_t;
141 :
142 : typedef struct {
143 : efi_guid_t guid;
144 : u32 headersize;
145 : u32 flags;
146 : u32 imagesize;
147 : } efi_capsule_header_t;
148 :
149 : /*
150 : * EFI capsule flags
151 : */
152 : #define EFI_CAPSULE_PERSIST_ACROSS_RESET 0x00010000
153 : #define EFI_CAPSULE_POPULATE_SYSTEM_TABLE 0x00020000
154 : #define EFI_CAPSULE_INITIATE_RESET 0x00040000
155 :
156 : struct capsule_info {
157 : efi_capsule_header_t header;
158 : efi_capsule_header_t *capsule;
159 : int reset_type;
160 : long index;
161 : size_t count;
162 : size_t total_size;
163 : struct page **pages;
164 : phys_addr_t *phys;
165 : size_t page_bytes_remain;
166 : };
167 :
168 : int __efi_capsule_setup_info(struct capsule_info *cap_info);
169 :
170 : /*
171 : * Types and defines for Time Services
172 : */
173 : #define EFI_TIME_ADJUST_DAYLIGHT 0x1
174 : #define EFI_TIME_IN_DAYLIGHT 0x2
175 : #define EFI_UNSPECIFIED_TIMEZONE 0x07ff
176 :
177 : typedef struct {
178 : u16 year;
179 : u8 month;
180 : u8 day;
181 : u8 hour;
182 : u8 minute;
183 : u8 second;
184 : u8 pad1;
185 : u32 nanosecond;
186 : s16 timezone;
187 : u8 daylight;
188 : u8 pad2;
189 : } efi_time_t;
190 :
191 : typedef struct {
192 : u32 resolution;
193 : u32 accuracy;
194 : u8 sets_to_zero;
195 : } efi_time_cap_t;
196 :
197 : typedef union efi_boot_services efi_boot_services_t;
198 :
199 : /*
200 : * Types and defines for EFI ResetSystem
201 : */
202 : #define EFI_RESET_COLD 0
203 : #define EFI_RESET_WARM 1
204 : #define EFI_RESET_SHUTDOWN 2
205 :
206 : /*
207 : * EFI Runtime Services table
208 : */
209 : #define EFI_RUNTIME_SERVICES_SIGNATURE ((u64)0x5652453544e5552ULL)
210 : #define EFI_RUNTIME_SERVICES_REVISION 0x00010000
211 :
212 : typedef struct {
213 : efi_table_hdr_t hdr;
214 : u32 get_time;
215 : u32 set_time;
216 : u32 get_wakeup_time;
217 : u32 set_wakeup_time;
218 : u32 set_virtual_address_map;
219 : u32 convert_pointer;
220 : u32 get_variable;
221 : u32 get_next_variable;
222 : u32 set_variable;
223 : u32 get_next_high_mono_count;
224 : u32 reset_system;
225 : u32 update_capsule;
226 : u32 query_capsule_caps;
227 : u32 query_variable_info;
228 : } efi_runtime_services_32_t;
229 :
230 : typedef efi_status_t efi_get_time_t (efi_time_t *tm, efi_time_cap_t *tc);
231 : typedef efi_status_t efi_set_time_t (efi_time_t *tm);
232 : typedef efi_status_t efi_get_wakeup_time_t (efi_bool_t *enabled, efi_bool_t *pending,
233 : efi_time_t *tm);
234 : typedef efi_status_t efi_set_wakeup_time_t (efi_bool_t enabled, efi_time_t *tm);
235 : typedef efi_status_t efi_get_variable_t (efi_char16_t *name, efi_guid_t *vendor, u32 *attr,
236 : unsigned long *data_size, void *data);
237 : typedef efi_status_t efi_get_next_variable_t (unsigned long *name_size, efi_char16_t *name,
238 : efi_guid_t *vendor);
239 : typedef efi_status_t efi_set_variable_t (efi_char16_t *name, efi_guid_t *vendor,
240 : u32 attr, unsigned long data_size,
241 : void *data);
242 : typedef efi_status_t efi_get_next_high_mono_count_t (u32 *count);
243 : typedef void efi_reset_system_t (int reset_type, efi_status_t status,
244 : unsigned long data_size, efi_char16_t *data);
245 : typedef efi_status_t efi_set_virtual_address_map_t (unsigned long memory_map_size,
246 : unsigned long descriptor_size,
247 : u32 descriptor_version,
248 : efi_memory_desc_t *virtual_map);
249 : typedef efi_status_t efi_query_variable_info_t(u32 attr,
250 : u64 *storage_space,
251 : u64 *remaining_space,
252 : u64 *max_variable_size);
253 : typedef efi_status_t efi_update_capsule_t(efi_capsule_header_t **capsules,
254 : unsigned long count,
255 : unsigned long sg_list);
256 : typedef efi_status_t efi_query_capsule_caps_t(efi_capsule_header_t **capsules,
257 : unsigned long count,
258 : u64 *max_size,
259 : int *reset_type);
260 : typedef efi_status_t efi_query_variable_store_t(u32 attributes,
261 : unsigned long size,
262 : bool nonblocking);
263 :
264 : typedef union {
265 : struct {
266 : efi_table_hdr_t hdr;
267 : efi_get_time_t __efiapi *get_time;
268 : efi_set_time_t __efiapi *set_time;
269 : efi_get_wakeup_time_t __efiapi *get_wakeup_time;
270 : efi_set_wakeup_time_t __efiapi *set_wakeup_time;
271 : efi_set_virtual_address_map_t __efiapi *set_virtual_address_map;
272 : void *convert_pointer;
273 : efi_get_variable_t __efiapi *get_variable;
274 : efi_get_next_variable_t __efiapi *get_next_variable;
275 : efi_set_variable_t __efiapi *set_variable;
276 : efi_get_next_high_mono_count_t __efiapi *get_next_high_mono_count;
277 : efi_reset_system_t __efiapi *reset_system;
278 : efi_update_capsule_t __efiapi *update_capsule;
279 : efi_query_capsule_caps_t __efiapi *query_capsule_caps;
280 : efi_query_variable_info_t __efiapi *query_variable_info;
281 : };
282 : efi_runtime_services_32_t mixed_mode;
283 : } efi_runtime_services_t;
284 :
285 : void efi_native_runtime_setup(void);
286 :
287 : /*
288 : * EFI Configuration Table and GUID definitions
289 : *
290 : * These are all defined in a single line to make them easier to
291 : * grep for and to see them at a glance - while still having a
292 : * similar structure to the definitions in the spec.
293 : *
294 : * Here's how they are structured:
295 : *
296 : * GUID: 12345678-1234-1234-1234-123456789012
297 : * Spec:
298 : * #define EFI_SOME_PROTOCOL_GUID \
299 : * {0x12345678,0x1234,0x1234,\
300 : * {0x12,0x34,0x12,0x34,0x56,0x78,0x90,0x12}}
301 : * Here:
302 : * #define SOME_PROTOCOL_GUID EFI_GUID(0x12345678, 0x1234, 0x1234, 0x12, 0x34, 0x12, 0x34, 0x56, 0x78, 0x90, 0x12)
303 : * ^ tabs ^extra space
304 : *
305 : * Note that the 'extra space' separates the values at the same place
306 : * where the UEFI SPEC breaks the line.
307 : */
308 : #define NULL_GUID EFI_GUID(0x00000000, 0x0000, 0x0000, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00)
309 : #define MPS_TABLE_GUID EFI_GUID(0xeb9d2d2f, 0x2d88, 0x11d3, 0x9a, 0x16, 0x00, 0x90, 0x27, 0x3f, 0xc1, 0x4d)
310 : #define ACPI_TABLE_GUID EFI_GUID(0xeb9d2d30, 0x2d88, 0x11d3, 0x9a, 0x16, 0x00, 0x90, 0x27, 0x3f, 0xc1, 0x4d)
311 : #define ACPI_20_TABLE_GUID EFI_GUID(0x8868e871, 0xe4f1, 0x11d3, 0xbc, 0x22, 0x00, 0x80, 0xc7, 0x3c, 0x88, 0x81)
312 : #define SMBIOS_TABLE_GUID EFI_GUID(0xeb9d2d31, 0x2d88, 0x11d3, 0x9a, 0x16, 0x00, 0x90, 0x27, 0x3f, 0xc1, 0x4d)
313 : #define SMBIOS3_TABLE_GUID EFI_GUID(0xf2fd1544, 0x9794, 0x4a2c, 0x99, 0x2e, 0xe5, 0xbb, 0xcf, 0x20, 0xe3, 0x94)
314 : #define SAL_SYSTEM_TABLE_GUID EFI_GUID(0xeb9d2d32, 0x2d88, 0x11d3, 0x9a, 0x16, 0x00, 0x90, 0x27, 0x3f, 0xc1, 0x4d)
315 : #define HCDP_TABLE_GUID EFI_GUID(0xf951938d, 0x620b, 0x42ef, 0x82, 0x79, 0xa8, 0x4b, 0x79, 0x61, 0x78, 0x98)
316 : #define UGA_IO_PROTOCOL_GUID EFI_GUID(0x61a4d49e, 0x6f68, 0x4f1b, 0xb9, 0x22, 0xa8, 0x6e, 0xed, 0x0b, 0x07, 0xa2)
317 : #define EFI_GLOBAL_VARIABLE_GUID EFI_GUID(0x8be4df61, 0x93ca, 0x11d2, 0xaa, 0x0d, 0x00, 0xe0, 0x98, 0x03, 0x2b, 0x8c)
318 : #define UV_SYSTEM_TABLE_GUID EFI_GUID(0x3b13a7d4, 0x633e, 0x11dd, 0x93, 0xec, 0xda, 0x25, 0x56, 0xd8, 0x95, 0x93)
319 : #define LINUX_EFI_CRASH_GUID EFI_GUID(0xcfc8fc79, 0xbe2e, 0x4ddc, 0x97, 0xf0, 0x9f, 0x98, 0xbf, 0xe2, 0x98, 0xa0)
320 : #define LOADED_IMAGE_PROTOCOL_GUID EFI_GUID(0x5b1b31a1, 0x9562, 0x11d2, 0x8e, 0x3f, 0x00, 0xa0, 0xc9, 0x69, 0x72, 0x3b)
321 : #define EFI_GRAPHICS_OUTPUT_PROTOCOL_GUID EFI_GUID(0x9042a9de, 0x23dc, 0x4a38, 0x96, 0xfb, 0x7a, 0xde, 0xd0, 0x80, 0x51, 0x6a)
322 : #define EFI_UGA_PROTOCOL_GUID EFI_GUID(0x982c298b, 0xf4fa, 0x41cb, 0xb8, 0x38, 0x77, 0xaa, 0x68, 0x8f, 0xb8, 0x39)
323 : #define EFI_PCI_IO_PROTOCOL_GUID EFI_GUID(0x4cf5b200, 0x68b8, 0x4ca5, 0x9e, 0xec, 0xb2, 0x3e, 0x3f, 0x50, 0x02, 0x9a)
324 : #define EFI_FILE_INFO_ID EFI_GUID(0x09576e92, 0x6d3f, 0x11d2, 0x8e, 0x39, 0x00, 0xa0, 0xc9, 0x69, 0x72, 0x3b)
325 : #define EFI_SYSTEM_RESOURCE_TABLE_GUID EFI_GUID(0xb122a263, 0x3661, 0x4f68, 0x99, 0x29, 0x78, 0xf8, 0xb0, 0xd6, 0x21, 0x80)
326 : #define EFI_FILE_SYSTEM_GUID EFI_GUID(0x964e5b22, 0x6459, 0x11d2, 0x8e, 0x39, 0x00, 0xa0, 0xc9, 0x69, 0x72, 0x3b)
327 : #define DEVICE_TREE_GUID EFI_GUID(0xb1b621d5, 0xf19c, 0x41a5, 0x83, 0x0b, 0xd9, 0x15, 0x2c, 0x69, 0xaa, 0xe0)
328 : #define EFI_PROPERTIES_TABLE_GUID EFI_GUID(0x880aaca3, 0x4adc, 0x4a04, 0x90, 0x79, 0xb7, 0x47, 0x34, 0x08, 0x25, 0xe5)
329 : #define EFI_RNG_PROTOCOL_GUID EFI_GUID(0x3152bca5, 0xeade, 0x433d, 0x86, 0x2e, 0xc0, 0x1c, 0xdc, 0x29, 0x1f, 0x44)
330 : #define EFI_RNG_ALGORITHM_RAW EFI_GUID(0xe43176d7, 0xb6e8, 0x4827, 0xb7, 0x84, 0x7f, 0xfd, 0xc4, 0xb6, 0x85, 0x61)
331 : #define EFI_MEMORY_ATTRIBUTES_TABLE_GUID EFI_GUID(0xdcfa911d, 0x26eb, 0x469f, 0xa2, 0x20, 0x38, 0xb7, 0xdc, 0x46, 0x12, 0x20)
332 : #define EFI_CONSOLE_OUT_DEVICE_GUID EFI_GUID(0xd3b36f2c, 0xd551, 0x11d4, 0x9a, 0x46, 0x00, 0x90, 0x27, 0x3f, 0xc1, 0x4d)
333 : #define APPLE_PROPERTIES_PROTOCOL_GUID EFI_GUID(0x91bd12fe, 0xf6c3, 0x44fb, 0xa5, 0xb7, 0x51, 0x22, 0xab, 0x30, 0x3a, 0xe0)
334 : #define EFI_TCG2_PROTOCOL_GUID EFI_GUID(0x607f766c, 0x7455, 0x42be, 0x93, 0x0b, 0xe4, 0xd7, 0x6d, 0xb2, 0x72, 0x0f)
335 : #define EFI_LOAD_FILE_PROTOCOL_GUID EFI_GUID(0x56ec3091, 0x954c, 0x11d2, 0x8e, 0x3f, 0x00, 0xa0, 0xc9, 0x69, 0x72, 0x3b)
336 : #define EFI_LOAD_FILE2_PROTOCOL_GUID EFI_GUID(0x4006c0c1, 0xfcb3, 0x403e, 0x99, 0x6d, 0x4a, 0x6c, 0x87, 0x24, 0xe0, 0x6d)
337 : #define EFI_RT_PROPERTIES_TABLE_GUID EFI_GUID(0xeb66918a, 0x7eef, 0x402a, 0x84, 0x2e, 0x93, 0x1d, 0x21, 0xc3, 0x8a, 0xe9)
338 :
339 : #define EFI_IMAGE_SECURITY_DATABASE_GUID EFI_GUID(0xd719b2cb, 0x3d3a, 0x4596, 0xa3, 0xbc, 0xda, 0xd0, 0x0e, 0x67, 0x65, 0x6f)
340 : #define EFI_SHIM_LOCK_GUID EFI_GUID(0x605dab50, 0xe046, 0x4300, 0xab, 0xb6, 0x3d, 0xd8, 0x10, 0xdd, 0x8b, 0x23)
341 :
342 : #define EFI_CERT_SHA256_GUID EFI_GUID(0xc1c41626, 0x504c, 0x4092, 0xac, 0xa9, 0x41, 0xf9, 0x36, 0x93, 0x43, 0x28)
343 : #define EFI_CERT_X509_GUID EFI_GUID(0xa5c059a1, 0x94e4, 0x4aa7, 0x87, 0xb5, 0xab, 0x15, 0x5c, 0x2b, 0xf0, 0x72)
344 : #define EFI_CERT_X509_SHA256_GUID EFI_GUID(0x3bd2a492, 0x96c0, 0x4079, 0xb4, 0x20, 0xfc, 0xf9, 0x8e, 0xf1, 0x03, 0xed)
345 :
346 : /*
347 : * This GUID is used to pass to the kernel proper the struct screen_info
348 : * structure that was populated by the stub based on the GOP protocol instance
349 : * associated with ConOut
350 : */
351 : #define LINUX_EFI_ARM_SCREEN_INFO_TABLE_GUID EFI_GUID(0xe03fc20a, 0x85dc, 0x406e, 0xb9, 0x0e, 0x4a, 0xb5, 0x02, 0x37, 0x1d, 0x95)
352 : #define LINUX_EFI_ARM_CPU_STATE_TABLE_GUID EFI_GUID(0xef79e4aa, 0x3c3d, 0x4989, 0xb9, 0x02, 0x07, 0xa9, 0x43, 0xe5, 0x50, 0xd2)
353 : #define LINUX_EFI_LOADER_ENTRY_GUID EFI_GUID(0x4a67b082, 0x0a4c, 0x41cf, 0xb6, 0xc7, 0x44, 0x0b, 0x29, 0xbb, 0x8c, 0x4f)
354 : #define LINUX_EFI_RANDOM_SEED_TABLE_GUID EFI_GUID(0x1ce1e5bc, 0x7ceb, 0x42f2, 0x81, 0xe5, 0x8a, 0xad, 0xf1, 0x80, 0xf5, 0x7b)
355 : #define LINUX_EFI_TPM_EVENT_LOG_GUID EFI_GUID(0xb7799cb0, 0xeca2, 0x4943, 0x96, 0x67, 0x1f, 0xae, 0x07, 0xb7, 0x47, 0xfa)
356 : #define LINUX_EFI_TPM_FINAL_LOG_GUID EFI_GUID(0x1e2ed096, 0x30e2, 0x4254, 0xbd, 0x89, 0x86, 0x3b, 0xbe, 0xf8, 0x23, 0x25)
357 : #define LINUX_EFI_MEMRESERVE_TABLE_GUID EFI_GUID(0x888eb0c6, 0x8ede, 0x4ff5, 0xa8, 0xf0, 0x9a, 0xee, 0x5c, 0xb9, 0x77, 0xc2)
358 : #define LINUX_EFI_INITRD_MEDIA_GUID EFI_GUID(0x5568e427, 0x68fc, 0x4f3d, 0xac, 0x74, 0xca, 0x55, 0x52, 0x31, 0xcc, 0x68)
359 : #define LINUX_EFI_MOK_VARIABLE_TABLE_GUID EFI_GUID(0xc451ed2b, 0x9694, 0x45d3, 0xba, 0xba, 0xed, 0x9f, 0x89, 0x88, 0xa3, 0x89)
360 :
361 : /* OEM GUIDs */
362 : #define DELLEMC_EFI_RCI2_TABLE_GUID EFI_GUID(0x2d9f28a2, 0xa886, 0x456a, 0x97, 0xa8, 0xf1, 0x1e, 0xf2, 0x4f, 0xf4, 0x55)
363 :
364 : typedef struct {
365 : efi_guid_t guid;
366 : u64 table;
367 : } efi_config_table_64_t;
368 :
369 : typedef struct {
370 : efi_guid_t guid;
371 : u32 table;
372 : } efi_config_table_32_t;
373 :
374 : typedef union {
375 : struct {
376 : efi_guid_t guid;
377 : void *table;
378 : };
379 : efi_config_table_32_t mixed_mode;
380 : } efi_config_table_t;
381 :
382 : typedef struct {
383 : efi_guid_t guid;
384 : unsigned long *ptr;
385 : const char name[16];
386 : } efi_config_table_type_t;
387 :
388 : #define EFI_SYSTEM_TABLE_SIGNATURE ((u64)0x5453595320494249ULL)
389 :
390 : #define EFI_2_30_SYSTEM_TABLE_REVISION ((2 << 16) | (30))
391 : #define EFI_2_20_SYSTEM_TABLE_REVISION ((2 << 16) | (20))
392 : #define EFI_2_10_SYSTEM_TABLE_REVISION ((2 << 16) | (10))
393 : #define EFI_2_00_SYSTEM_TABLE_REVISION ((2 << 16) | (00))
394 : #define EFI_1_10_SYSTEM_TABLE_REVISION ((1 << 16) | (10))
395 : #define EFI_1_02_SYSTEM_TABLE_REVISION ((1 << 16) | (02))
396 :
397 : typedef struct {
398 : efi_table_hdr_t hdr;
399 : u64 fw_vendor; /* physical addr of CHAR16 vendor string */
400 : u32 fw_revision;
401 : u32 __pad1;
402 : u64 con_in_handle;
403 : u64 con_in;
404 : u64 con_out_handle;
405 : u64 con_out;
406 : u64 stderr_handle;
407 : u64 stderr;
408 : u64 runtime;
409 : u64 boottime;
410 : u32 nr_tables;
411 : u32 __pad2;
412 : u64 tables;
413 : } efi_system_table_64_t;
414 :
415 : typedef struct {
416 : efi_table_hdr_t hdr;
417 : u32 fw_vendor; /* physical addr of CHAR16 vendor string */
418 : u32 fw_revision;
419 : u32 con_in_handle;
420 : u32 con_in;
421 : u32 con_out_handle;
422 : u32 con_out;
423 : u32 stderr_handle;
424 : u32 stderr;
425 : u32 runtime;
426 : u32 boottime;
427 : u32 nr_tables;
428 : u32 tables;
429 : } efi_system_table_32_t;
430 :
431 : typedef union efi_simple_text_input_protocol efi_simple_text_input_protocol_t;
432 : typedef union efi_simple_text_output_protocol efi_simple_text_output_protocol_t;
433 :
434 : typedef union {
435 : struct {
436 : efi_table_hdr_t hdr;
437 : unsigned long fw_vendor; /* physical addr of CHAR16 vendor string */
438 : u32 fw_revision;
439 : unsigned long con_in_handle;
440 : efi_simple_text_input_protocol_t *con_in;
441 : unsigned long con_out_handle;
442 : efi_simple_text_output_protocol_t *con_out;
443 : unsigned long stderr_handle;
444 : unsigned long stderr;
445 : efi_runtime_services_t *runtime;
446 : efi_boot_services_t *boottime;
447 : unsigned long nr_tables;
448 : unsigned long tables;
449 : };
450 : efi_system_table_32_t mixed_mode;
451 : } efi_system_table_t;
452 :
453 : /*
454 : * Architecture independent structure for describing a memory map for the
455 : * benefit of efi_memmap_init_early(), and for passing context between
456 : * efi_memmap_alloc() and efi_memmap_install().
457 : */
458 : struct efi_memory_map_data {
459 : phys_addr_t phys_map;
460 : unsigned long size;
461 : unsigned long desc_version;
462 : unsigned long desc_size;
463 : unsigned long flags;
464 : };
465 :
466 : struct efi_memory_map {
467 : phys_addr_t phys_map;
468 : void *map;
469 : void *map_end;
470 : int nr_map;
471 : unsigned long desc_version;
472 : unsigned long desc_size;
473 : #define EFI_MEMMAP_LATE (1UL << 0)
474 : #define EFI_MEMMAP_MEMBLOCK (1UL << 1)
475 : #define EFI_MEMMAP_SLAB (1UL << 2)
476 : unsigned long flags;
477 : };
478 :
479 : struct efi_mem_range {
480 : struct range range;
481 : u64 attribute;
482 : };
483 :
484 : typedef struct {
485 : u32 version;
486 : u32 length;
487 : u64 memory_protection_attribute;
488 : } efi_properties_table_t;
489 :
490 : #define EFI_PROPERTIES_TABLE_VERSION 0x00010000
491 : #define EFI_PROPERTIES_RUNTIME_MEMORY_PROTECTION_NON_EXECUTABLE_PE_DATA 0x1
492 :
493 : typedef struct {
494 : u16 version;
495 : u16 length;
496 : u32 runtime_services_supported;
497 : } efi_rt_properties_table_t;
498 :
499 : #define EFI_RT_PROPERTIES_TABLE_VERSION 0x1
500 :
501 : #define EFI_INVALID_TABLE_ADDR (~0UL)
502 :
503 : typedef struct {
504 : u32 version;
505 : u32 num_entries;
506 : u32 desc_size;
507 : u32 reserved;
508 : efi_memory_desc_t entry[0];
509 : } efi_memory_attributes_table_t;
510 :
511 : typedef struct {
512 : efi_guid_t signature_owner;
513 : u8 signature_data[];
514 : } efi_signature_data_t;
515 :
516 : typedef struct {
517 : efi_guid_t signature_type;
518 : u32 signature_list_size;
519 : u32 signature_header_size;
520 : u32 signature_size;
521 : u8 signature_header[];
522 : /* efi_signature_data_t signatures[][] */
523 : } efi_signature_list_t;
524 :
525 : typedef u8 efi_sha256_hash_t[32];
526 :
527 : typedef struct {
528 : efi_sha256_hash_t to_be_signed_hash;
529 : efi_time_t time_of_revocation;
530 : } efi_cert_x509_sha256_t;
531 :
532 : extern unsigned long __ro_after_init efi_rng_seed; /* RNG Seed table */
533 :
534 : /*
535 : * All runtime access to EFI goes through this structure:
536 : */
537 : extern struct efi {
538 : const efi_runtime_services_t *runtime; /* EFI runtime services table */
539 : unsigned int runtime_version; /* Runtime services version */
540 : unsigned int runtime_supported_mask;
541 :
542 : unsigned long acpi; /* ACPI table (IA64 ext 0.71) */
543 : unsigned long acpi20; /* ACPI table (ACPI 2.0) */
544 : unsigned long smbios; /* SMBIOS table (32 bit entry point) */
545 : unsigned long smbios3; /* SMBIOS table (64 bit entry point) */
546 : unsigned long esrt; /* ESRT table */
547 : unsigned long tpm_log; /* TPM2 Event Log table */
548 : unsigned long tpm_final_log; /* TPM2 Final Events Log table */
549 : unsigned long mokvar_table; /* MOK variable config table */
550 :
551 : efi_get_time_t *get_time;
552 : efi_set_time_t *set_time;
553 : efi_get_wakeup_time_t *get_wakeup_time;
554 : efi_set_wakeup_time_t *set_wakeup_time;
555 : efi_get_variable_t *get_variable;
556 : efi_get_next_variable_t *get_next_variable;
557 : efi_set_variable_t *set_variable;
558 : efi_set_variable_t *set_variable_nonblocking;
559 : efi_query_variable_info_t *query_variable_info;
560 : efi_query_variable_info_t *query_variable_info_nonblocking;
561 : efi_update_capsule_t *update_capsule;
562 : efi_query_capsule_caps_t *query_capsule_caps;
563 : efi_get_next_high_mono_count_t *get_next_high_mono_count;
564 : efi_reset_system_t *reset_system;
565 :
566 : struct efi_memory_map memmap;
567 : unsigned long flags;
568 : } efi;
569 :
570 : #define EFI_RT_SUPPORTED_GET_TIME 0x0001
571 : #define EFI_RT_SUPPORTED_SET_TIME 0x0002
572 : #define EFI_RT_SUPPORTED_GET_WAKEUP_TIME 0x0004
573 : #define EFI_RT_SUPPORTED_SET_WAKEUP_TIME 0x0008
574 : #define EFI_RT_SUPPORTED_GET_VARIABLE 0x0010
575 : #define EFI_RT_SUPPORTED_GET_NEXT_VARIABLE_NAME 0x0020
576 : #define EFI_RT_SUPPORTED_SET_VARIABLE 0x0040
577 : #define EFI_RT_SUPPORTED_SET_VIRTUAL_ADDRESS_MAP 0x0080
578 : #define EFI_RT_SUPPORTED_CONVERT_POINTER 0x0100
579 : #define EFI_RT_SUPPORTED_GET_NEXT_HIGH_MONOTONIC_COUNT 0x0200
580 : #define EFI_RT_SUPPORTED_RESET_SYSTEM 0x0400
581 : #define EFI_RT_SUPPORTED_UPDATE_CAPSULE 0x0800
582 : #define EFI_RT_SUPPORTED_QUERY_CAPSULE_CAPABILITIES 0x1000
583 : #define EFI_RT_SUPPORTED_QUERY_VARIABLE_INFO 0x2000
584 :
585 : #define EFI_RT_SUPPORTED_ALL 0x3fff
586 :
587 : #define EFI_RT_SUPPORTED_TIME_SERVICES 0x000f
588 : #define EFI_RT_SUPPORTED_VARIABLE_SERVICES 0x0070
589 :
590 : extern struct mm_struct efi_mm;
591 :
592 : static inline int
593 : efi_guidcmp (efi_guid_t left, efi_guid_t right)
594 : {
595 : return memcmp(&left, &right, sizeof (efi_guid_t));
596 : }
597 :
598 : static inline char *
599 : efi_guid_to_str(efi_guid_t *guid, char *out)
600 : {
601 : sprintf(out, "%pUl", guid->b);
602 : return out;
603 : }
604 :
605 : extern void efi_init (void);
606 : #ifdef CONFIG_EFI
607 : extern void efi_enter_virtual_mode (void); /* switch EFI to virtual mode, if possible */
608 : #else
609 : static inline void efi_enter_virtual_mode (void) {}
610 : #endif
611 : #ifdef CONFIG_X86
612 : extern efi_status_t efi_query_variable_store(u32 attributes,
613 : unsigned long size,
614 : bool nonblocking);
615 : #else
616 :
617 : static inline efi_status_t efi_query_variable_store(u32 attributes,
618 : unsigned long size,
619 : bool nonblocking)
620 : {
621 : return EFI_SUCCESS;
622 : }
623 : #endif
624 : extern void __iomem *efi_lookup_mapped_addr(u64 phys_addr);
625 :
626 : extern int __init efi_memmap_alloc(unsigned int num_entries,
627 : struct efi_memory_map_data *data);
628 : extern void __efi_memmap_free(u64 phys, unsigned long size,
629 : unsigned long flags);
630 : extern int __init efi_memmap_init_early(struct efi_memory_map_data *data);
631 : extern int __init efi_memmap_init_late(phys_addr_t addr, unsigned long size);
632 : extern void __init efi_memmap_unmap(void);
633 : extern int __init efi_memmap_install(struct efi_memory_map_data *data);
634 : extern int __init efi_memmap_split_count(efi_memory_desc_t *md,
635 : struct range *range);
636 : extern void __init efi_memmap_insert(struct efi_memory_map *old_memmap,
637 : void *buf, struct efi_mem_range *mem);
638 :
639 : #ifdef CONFIG_EFI_ESRT
640 : extern void __init efi_esrt_init(void);
641 : #else
642 1 : static inline void efi_esrt_init(void) { }
643 : #endif
644 : extern int efi_config_parse_tables(const efi_config_table_t *config_tables,
645 : int count,
646 : const efi_config_table_type_t *arch_tables);
647 : extern int efi_systab_check_header(const efi_table_hdr_t *systab_hdr,
648 : int min_major_version);
649 : extern void efi_systab_report_header(const efi_table_hdr_t *systab_hdr,
650 : unsigned long fw_vendor);
651 : extern u64 efi_get_iobase (void);
652 : extern int efi_mem_type(unsigned long phys_addr);
653 : extern u64 efi_mem_attributes (unsigned long phys_addr);
654 : extern u64 efi_mem_attribute (unsigned long phys_addr, unsigned long size);
655 : extern int __init efi_uart_console_only (void);
656 : extern u64 efi_mem_desc_end(efi_memory_desc_t *md);
657 : extern int efi_mem_desc_lookup(u64 phys_addr, efi_memory_desc_t *out_md);
658 : extern void efi_mem_reserve(phys_addr_t addr, u64 size);
659 : extern int efi_mem_reserve_persistent(phys_addr_t addr, u64 size);
660 : extern void efi_initialize_iomem_resources(struct resource *code_resource,
661 : struct resource *data_resource, struct resource *bss_resource);
662 : extern u64 efi_get_fdt_params(struct efi_memory_map_data *data);
663 : extern struct kobject *efi_kobj;
664 :
665 : extern int efi_reboot_quirk_mode;
666 : extern bool efi_poweroff_required(void);
667 :
668 : #ifdef CONFIG_EFI_FAKE_MEMMAP
669 : extern void __init efi_fake_memmap(void);
670 : #else
671 1 : static inline void efi_fake_memmap(void) { }
672 : #endif
673 :
674 : extern unsigned long efi_mem_attr_table;
675 :
676 : /*
677 : * efi_memattr_perm_setter - arch specific callback function passed into
678 : * efi_memattr_apply_permissions() that updates the
679 : * mapping permissions described by the second
680 : * argument in the page tables referred to by the
681 : * first argument.
682 : */
683 : typedef int (*efi_memattr_perm_setter)(struct mm_struct *, efi_memory_desc_t *);
684 :
685 : extern int efi_memattr_init(void);
686 : extern int efi_memattr_apply_permissions(struct mm_struct *mm,
687 : efi_memattr_perm_setter fn);
688 :
689 : /*
690 : * efi_early_memdesc_ptr - get the n-th EFI memmap descriptor
691 : * @map: the start of efi memmap
692 : * @desc_size: the size of space for each EFI memmap descriptor
693 : * @n: the index of efi memmap descriptor
694 : *
695 : * EFI boot service provides the GetMemoryMap() function to get a copy of the
696 : * current memory map which is an array of memory descriptors, each of
697 : * which describes a contiguous block of memory. It also gets the size of the
698 : * map, and the size of each descriptor, etc.
699 : *
700 : * Note that per section 6.2 of UEFI Spec 2.6 Errata A, the returned size of
701 : * each descriptor might not be equal to sizeof(efi_memory_memdesc_t),
702 : * since efi_memory_memdesc_t may be extended in the future. Thus the OS
703 : * MUST use the returned size of the descriptor to find the start of each
704 : * efi_memory_memdesc_t in the memory map array. This should only be used
705 : * during bootup since for_each_efi_memory_desc_xxx() is available after the
706 : * kernel initializes the EFI subsystem to set up struct efi_memory_map.
707 : */
708 : #define efi_early_memdesc_ptr(map, desc_size, n) \
709 : (efi_memory_desc_t *)((void *)(map) + ((n) * (desc_size)))
710 :
711 : /* Iterate through an efi_memory_map */
712 : #define for_each_efi_memory_desc_in_map(m, md) \
713 : for ((md) = (m)->map; \
714 : (md) && ((void *)(md) + (m)->desc_size) <= (m)->map_end; \
715 : (md) = (void *)(md) + (m)->desc_size)
716 :
717 : /**
718 : * for_each_efi_memory_desc - iterate over descriptors in efi.memmap
719 : * @md: the efi_memory_desc_t * iterator
720 : *
721 : * Once the loop finishes @md must not be accessed.
722 : */
723 : #define for_each_efi_memory_desc(md) \
724 : for_each_efi_memory_desc_in_map(&efi.memmap, md)
725 :
726 : /*
727 : * Format an EFI memory descriptor's type and attributes to a user-provided
728 : * character buffer, as per snprintf(), and return the buffer.
729 : */
730 : char * __init efi_md_typeattr_format(char *buf, size_t size,
731 : const efi_memory_desc_t *md);
732 :
733 :
734 : typedef void (*efi_element_handler_t)(const char *source,
735 : const void *element_data,
736 : size_t element_size);
737 : extern int __init parse_efi_signature_list(
738 : const char *source,
739 : const void *data, size_t size,
740 : efi_element_handler_t (*get_handler_for_guid)(const efi_guid_t *));
741 :
742 : /**
743 : * efi_range_is_wc - check the WC bit on an address range
744 : * @start: starting kvirt address
745 : * @len: length of range
746 : *
747 : * Consult the EFI memory map and make sure it's ok to set this range WC.
748 : * Returns true or false.
749 : */
750 : static inline int efi_range_is_wc(unsigned long start, unsigned long len)
751 : {
752 : unsigned long i;
753 :
754 : for (i = 0; i < len; i += (1UL << EFI_PAGE_SHIFT)) {
755 : unsigned long paddr = __pa(start + i);
756 : if (!(efi_mem_attributes(paddr) & EFI_MEMORY_WC))
757 : return 0;
758 : }
759 : /* The range checked out */
760 : return 1;
761 : }
762 :
763 : #ifdef CONFIG_EFI_PCDP
764 : extern int __init efi_setup_pcdp_console(char *);
765 : #endif
766 :
767 : /*
768 : * We play games with efi_enabled so that the compiler will, if
769 : * possible, remove EFI-related code altogether.
770 : */
771 : #define EFI_BOOT 0 /* Were we booted from EFI? */
772 : #define EFI_CONFIG_TABLES 2 /* Can we use EFI config tables? */
773 : #define EFI_RUNTIME_SERVICES 3 /* Can we use runtime services? */
774 : #define EFI_MEMMAP 4 /* Can we use EFI memory map? */
775 : #define EFI_64BIT 5 /* Is the firmware 64-bit? */
776 : #define EFI_PARAVIRT 6 /* Access is via a paravirt interface */
777 : #define EFI_ARCH_1 7 /* First arch-specific bit */
778 : #define EFI_DBG 8 /* Print additional debug info at runtime */
779 : #define EFI_NX_PE_DATA 9 /* Can runtime data regions be mapped non-executable? */
780 : #define EFI_MEM_ATTR 10 /* Did firmware publish an EFI_MEMORY_ATTRIBUTES table? */
781 : #define EFI_MEM_NO_SOFT_RESERVE 11 /* Is the kernel configured to ignore soft reservations? */
782 : #define EFI_PRESERVE_BS_REGIONS 12 /* Are EFI boot-services memory segments available? */
783 :
784 : #ifdef CONFIG_EFI
785 : /*
786 : * Test whether the above EFI_* bits are enabled.
787 : */
788 : static inline bool efi_enabled(int feature)
789 : {
790 : return test_bit(feature, &efi.flags) != 0;
791 : }
792 : extern void efi_reboot(enum reboot_mode reboot_mode, const char *__unused);
793 :
794 : bool __pure __efi_soft_reserve_enabled(void);
795 :
796 : static inline bool __pure efi_soft_reserve_enabled(void)
797 : {
798 : return IS_ENABLED(CONFIG_EFI_SOFT_RESERVE)
799 : && __efi_soft_reserve_enabled();
800 : }
801 :
802 : static inline bool efi_rt_services_supported(unsigned int mask)
803 : {
804 : return (efi.runtime_supported_mask & mask) == mask;
805 : }
806 : #else
807 3 : static inline bool efi_enabled(int feature)
808 : {
809 3 : return false;
810 : }
811 : static inline void
812 0 : efi_reboot(enum reboot_mode reboot_mode, const char *__unused) {}
813 :
814 : static inline bool efi_soft_reserve_enabled(void)
815 : {
816 : return false;
817 : }
818 :
819 : static inline bool efi_rt_services_supported(unsigned int mask)
820 : {
821 : return false;
822 : }
823 : #endif
824 :
825 : extern int efi_status_to_err(efi_status_t status);
826 :
827 : /*
828 : * Variable Attributes
829 : */
830 : #define EFI_VARIABLE_NON_VOLATILE 0x0000000000000001
831 : #define EFI_VARIABLE_BOOTSERVICE_ACCESS 0x0000000000000002
832 : #define EFI_VARIABLE_RUNTIME_ACCESS 0x0000000000000004
833 : #define EFI_VARIABLE_HARDWARE_ERROR_RECORD 0x0000000000000008
834 : #define EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS 0x0000000000000010
835 : #define EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS 0x0000000000000020
836 : #define EFI_VARIABLE_APPEND_WRITE 0x0000000000000040
837 :
838 : #define EFI_VARIABLE_MASK (EFI_VARIABLE_NON_VOLATILE | \
839 : EFI_VARIABLE_BOOTSERVICE_ACCESS | \
840 : EFI_VARIABLE_RUNTIME_ACCESS | \
841 : EFI_VARIABLE_HARDWARE_ERROR_RECORD | \
842 : EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS | \
843 : EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS | \
844 : EFI_VARIABLE_APPEND_WRITE)
845 : /*
846 : * Length of a GUID string (strlen("aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee"))
847 : * not including trailing NUL
848 : */
849 : #define EFI_VARIABLE_GUID_LEN UUID_STRING_LEN
850 :
851 : /*
852 : * EFI Device Path information
853 : */
854 : #define EFI_DEV_HW 0x01
855 : #define EFI_DEV_PCI 1
856 : #define EFI_DEV_PCCARD 2
857 : #define EFI_DEV_MEM_MAPPED 3
858 : #define EFI_DEV_VENDOR 4
859 : #define EFI_DEV_CONTROLLER 5
860 : #define EFI_DEV_ACPI 0x02
861 : #define EFI_DEV_BASIC_ACPI 1
862 : #define EFI_DEV_EXPANDED_ACPI 2
863 : #define EFI_DEV_MSG 0x03
864 : #define EFI_DEV_MSG_ATAPI 1
865 : #define EFI_DEV_MSG_SCSI 2
866 : #define EFI_DEV_MSG_FC 3
867 : #define EFI_DEV_MSG_1394 4
868 : #define EFI_DEV_MSG_USB 5
869 : #define EFI_DEV_MSG_USB_CLASS 15
870 : #define EFI_DEV_MSG_I20 6
871 : #define EFI_DEV_MSG_MAC 11
872 : #define EFI_DEV_MSG_IPV4 12
873 : #define EFI_DEV_MSG_IPV6 13
874 : #define EFI_DEV_MSG_INFINIBAND 9
875 : #define EFI_DEV_MSG_UART 14
876 : #define EFI_DEV_MSG_VENDOR 10
877 : #define EFI_DEV_MEDIA 0x04
878 : #define EFI_DEV_MEDIA_HARD_DRIVE 1
879 : #define EFI_DEV_MEDIA_CDROM 2
880 : #define EFI_DEV_MEDIA_VENDOR 3
881 : #define EFI_DEV_MEDIA_FILE 4
882 : #define EFI_DEV_MEDIA_PROTOCOL 5
883 : #define EFI_DEV_BIOS_BOOT 0x05
884 : #define EFI_DEV_END_PATH 0x7F
885 : #define EFI_DEV_END_PATH2 0xFF
886 : #define EFI_DEV_END_INSTANCE 0x01
887 : #define EFI_DEV_END_ENTIRE 0xFF
888 :
889 : struct efi_generic_dev_path {
890 : u8 type;
891 : u8 sub_type;
892 : u16 length;
893 : } __packed;
894 :
895 : struct efi_acpi_dev_path {
896 : struct efi_generic_dev_path header;
897 : u32 hid;
898 : u32 uid;
899 : } __packed;
900 :
901 : struct efi_pci_dev_path {
902 : struct efi_generic_dev_path header;
903 : u8 fn;
904 : u8 dev;
905 : } __packed;
906 :
907 : struct efi_vendor_dev_path {
908 : struct efi_generic_dev_path header;
909 : efi_guid_t vendorguid;
910 : u8 vendordata[];
911 : } __packed;
912 :
913 : struct efi_dev_path {
914 : union {
915 : struct efi_generic_dev_path header;
916 : struct efi_acpi_dev_path acpi;
917 : struct efi_pci_dev_path pci;
918 : struct efi_vendor_dev_path vendor;
919 : };
920 : } __packed;
921 :
922 : struct device *efi_get_device_by_path(const struct efi_dev_path **node,
923 : size_t *len);
924 :
925 : static inline void memrange_efi_to_native(u64 *addr, u64 *npages)
926 : {
927 : *npages = PFN_UP(*addr + (*npages<<EFI_PAGE_SHIFT)) - PFN_DOWN(*addr);
928 : *addr &= PAGE_MASK;
929 : }
930 :
931 : /*
932 : * EFI Variable support.
933 : *
934 : * Different firmware drivers can expose their EFI-like variables using
935 : * the following.
936 : */
937 :
938 : struct efivar_operations {
939 : efi_get_variable_t *get_variable;
940 : efi_get_next_variable_t *get_next_variable;
941 : efi_set_variable_t *set_variable;
942 : efi_set_variable_t *set_variable_nonblocking;
943 : efi_query_variable_store_t *query_variable_store;
944 : };
945 :
946 : struct efivars {
947 : struct kset *kset;
948 : struct kobject *kobject;
949 : const struct efivar_operations *ops;
950 : };
951 :
952 : /*
953 : * The maximum size of VariableName + Data = 1024
954 : * Therefore, it's reasonable to save that much
955 : * space in each part of the structure,
956 : * and we use a page for reading/writing.
957 : */
958 :
959 : #define EFI_VAR_NAME_LEN 1024
960 :
961 : struct efi_variable {
962 : efi_char16_t VariableName[EFI_VAR_NAME_LEN/sizeof(efi_char16_t)];
963 : efi_guid_t VendorGuid;
964 : unsigned long DataSize;
965 : __u8 Data[1024];
966 : efi_status_t Status;
967 : __u32 Attributes;
968 : } __attribute__((packed));
969 :
970 : struct efivar_entry {
971 : struct efi_variable var;
972 : struct list_head list;
973 : struct kobject kobj;
974 : bool scanning;
975 : bool deleting;
976 : };
977 :
978 : static inline void
979 : efivar_unregister(struct efivar_entry *var)
980 : {
981 : kobject_put(&var->kobj);
982 : }
983 :
984 : int efivars_register(struct efivars *efivars,
985 : const struct efivar_operations *ops,
986 : struct kobject *kobject);
987 : int efivars_unregister(struct efivars *efivars);
988 : struct kobject *efivars_kobject(void);
989 :
990 : int efivar_supports_writes(void);
991 : int efivar_init(int (*func)(efi_char16_t *, efi_guid_t, unsigned long, void *),
992 : void *data, bool duplicates, struct list_head *head);
993 :
994 : int efivar_entry_add(struct efivar_entry *entry, struct list_head *head);
995 : int efivar_entry_remove(struct efivar_entry *entry);
996 :
997 : int __efivar_entry_delete(struct efivar_entry *entry);
998 : int efivar_entry_delete(struct efivar_entry *entry);
999 :
1000 : int efivar_entry_size(struct efivar_entry *entry, unsigned long *size);
1001 : int __efivar_entry_get(struct efivar_entry *entry, u32 *attributes,
1002 : unsigned long *size, void *data);
1003 : int efivar_entry_get(struct efivar_entry *entry, u32 *attributes,
1004 : unsigned long *size, void *data);
1005 : int efivar_entry_set(struct efivar_entry *entry, u32 attributes,
1006 : unsigned long size, void *data, struct list_head *head);
1007 : int efivar_entry_set_get_size(struct efivar_entry *entry, u32 attributes,
1008 : unsigned long *size, void *data, bool *set);
1009 : int efivar_entry_set_safe(efi_char16_t *name, efi_guid_t vendor, u32 attributes,
1010 : bool block, unsigned long size, void *data);
1011 :
1012 : int efivar_entry_iter_begin(void);
1013 : void efivar_entry_iter_end(void);
1014 :
1015 : int __efivar_entry_iter(int (*func)(struct efivar_entry *, void *),
1016 : struct list_head *head, void *data,
1017 : struct efivar_entry **prev);
1018 : int efivar_entry_iter(int (*func)(struct efivar_entry *, void *),
1019 : struct list_head *head, void *data);
1020 :
1021 : struct efivar_entry *efivar_entry_find(efi_char16_t *name, efi_guid_t guid,
1022 : struct list_head *head, bool remove);
1023 :
1024 : bool efivar_validate(efi_guid_t vendor, efi_char16_t *var_name, u8 *data,
1025 : unsigned long data_size);
1026 : bool efivar_variable_is_removable(efi_guid_t vendor, const char *name,
1027 : size_t len);
1028 :
1029 : #if IS_ENABLED(CONFIG_EFI_CAPSULE_LOADER)
1030 : extern bool efi_capsule_pending(int *reset_type);
1031 :
1032 : extern int efi_capsule_supported(efi_guid_t guid, u32 flags,
1033 : size_t size, int *reset);
1034 :
1035 : extern int efi_capsule_update(efi_capsule_header_t *capsule,
1036 : phys_addr_t *pages);
1037 : #else
1038 0 : static inline bool efi_capsule_pending(int *reset_type) { return false; }
1039 : #endif
1040 :
1041 : #ifdef CONFIG_EFI_RUNTIME_MAP
1042 : int efi_runtime_map_init(struct kobject *);
1043 : int efi_get_runtime_map_size(void);
1044 : int efi_get_runtime_map_desc_size(void);
1045 : int efi_runtime_map_copy(void *buf, size_t bufsz);
1046 : #else
1047 : static inline int efi_runtime_map_init(struct kobject *kobj)
1048 : {
1049 : return 0;
1050 : }
1051 :
1052 : static inline int efi_get_runtime_map_size(void)
1053 : {
1054 : return 0;
1055 : }
1056 :
1057 : static inline int efi_get_runtime_map_desc_size(void)
1058 : {
1059 : return 0;
1060 : }
1061 :
1062 : static inline int efi_runtime_map_copy(void *buf, size_t bufsz)
1063 : {
1064 : return 0;
1065 : }
1066 :
1067 : #endif
1068 :
1069 : #ifdef CONFIG_EFI
1070 : extern bool efi_runtime_disabled(void);
1071 : #else
1072 : static inline bool efi_runtime_disabled(void) { return true; }
1073 : #endif
1074 :
1075 : extern void efi_call_virt_check_flags(unsigned long flags, const char *call);
1076 : extern unsigned long efi_call_virt_save_flags(void);
1077 :
1078 : enum efi_secureboot_mode {
1079 : efi_secureboot_mode_unset,
1080 : efi_secureboot_mode_unknown,
1081 : efi_secureboot_mode_disabled,
1082 : efi_secureboot_mode_enabled,
1083 : };
1084 :
1085 : static inline
1086 : enum efi_secureboot_mode efi_get_secureboot_mode(efi_get_variable_t *get_var)
1087 : {
1088 : u8 secboot, setupmode = 0;
1089 : efi_status_t status;
1090 : unsigned long size;
1091 :
1092 : size = sizeof(secboot);
1093 : status = get_var(L"SecureBoot", &EFI_GLOBAL_VARIABLE_GUID, NULL, &size,
1094 : &secboot);
1095 : if (status == EFI_NOT_FOUND)
1096 : return efi_secureboot_mode_disabled;
1097 : if (status != EFI_SUCCESS)
1098 : return efi_secureboot_mode_unknown;
1099 :
1100 : size = sizeof(setupmode);
1101 : get_var(L"SetupMode", &EFI_GLOBAL_VARIABLE_GUID, NULL, &size, &setupmode);
1102 : if (secboot == 0 || setupmode == 1)
1103 : return efi_secureboot_mode_disabled;
1104 : return efi_secureboot_mode_enabled;
1105 : }
1106 :
1107 : #ifdef CONFIG_EFI_EMBEDDED_FIRMWARE
1108 : void efi_check_for_embedded_firmwares(void);
1109 : #else
1110 : static inline void efi_check_for_embedded_firmwares(void) { }
1111 : #endif
1112 :
1113 : efi_status_t efi_random_get_seed(void);
1114 :
1115 : /*
1116 : * Arch code can implement the following three template macros, avoiding
1117 : * reptition for the void/non-void return cases of {__,}efi_call_virt():
1118 : *
1119 : * * arch_efi_call_virt_setup()
1120 : *
1121 : * Sets up the environment for the call (e.g. switching page tables,
1122 : * allowing kernel-mode use of floating point, if required).
1123 : *
1124 : * * arch_efi_call_virt()
1125 : *
1126 : * Performs the call. The last expression in the macro must be the call
1127 : * itself, allowing the logic to be shared by the void and non-void
1128 : * cases.
1129 : *
1130 : * * arch_efi_call_virt_teardown()
1131 : *
1132 : * Restores the usual kernel environment once the call has returned.
1133 : */
1134 :
1135 : #define efi_call_virt_pointer(p, f, args...) \
1136 : ({ \
1137 : efi_status_t __s; \
1138 : unsigned long __flags; \
1139 : \
1140 : arch_efi_call_virt_setup(); \
1141 : \
1142 : __flags = efi_call_virt_save_flags(); \
1143 : __s = arch_efi_call_virt(p, f, args); \
1144 : efi_call_virt_check_flags(__flags, __stringify(f)); \
1145 : \
1146 : arch_efi_call_virt_teardown(); \
1147 : \
1148 : __s; \
1149 : })
1150 :
1151 : #define __efi_call_virt_pointer(p, f, args...) \
1152 : ({ \
1153 : unsigned long __flags; \
1154 : \
1155 : arch_efi_call_virt_setup(); \
1156 : \
1157 : __flags = efi_call_virt_save_flags(); \
1158 : arch_efi_call_virt(p, f, args); \
1159 : efi_call_virt_check_flags(__flags, __stringify(f)); \
1160 : \
1161 : arch_efi_call_virt_teardown(); \
1162 : })
1163 :
1164 : #define EFI_RANDOM_SEED_SIZE 64U
1165 :
1166 : struct linux_efi_random_seed {
1167 : u32 size;
1168 : u8 bits[];
1169 : };
1170 :
1171 : struct linux_efi_tpm_eventlog {
1172 : u32 size;
1173 : u32 final_events_preboot_size;
1174 : u8 version;
1175 : u8 log[];
1176 : };
1177 :
1178 : extern int efi_tpm_eventlog_init(void);
1179 :
1180 : struct efi_tcg2_final_events_table {
1181 : u64 version;
1182 : u64 nr_events;
1183 : u8 events[];
1184 : };
1185 : extern int efi_tpm_final_log_size;
1186 :
1187 : extern unsigned long rci2_table_phys;
1188 :
1189 : /*
1190 : * efi_runtime_service() function identifiers.
1191 : * "NONE" is used by efi_recover_from_page_fault() to check if the page
1192 : * fault happened while executing an efi runtime service.
1193 : */
1194 : enum efi_rts_ids {
1195 : EFI_NONE,
1196 : EFI_GET_TIME,
1197 : EFI_SET_TIME,
1198 : EFI_GET_WAKEUP_TIME,
1199 : EFI_SET_WAKEUP_TIME,
1200 : EFI_GET_VARIABLE,
1201 : EFI_GET_NEXT_VARIABLE,
1202 : EFI_SET_VARIABLE,
1203 : EFI_QUERY_VARIABLE_INFO,
1204 : EFI_GET_NEXT_HIGH_MONO_COUNT,
1205 : EFI_RESET_SYSTEM,
1206 : EFI_UPDATE_CAPSULE,
1207 : EFI_QUERY_CAPSULE_CAPS,
1208 : };
1209 :
1210 : /*
1211 : * efi_runtime_work: Details of EFI Runtime Service work
1212 : * @arg<1-5>: EFI Runtime Service function arguments
1213 : * @status: Status of executing EFI Runtime Service
1214 : * @efi_rts_id: EFI Runtime Service function identifier
1215 : * @efi_rts_comp: Struct used for handling completions
1216 : */
1217 : struct efi_runtime_work {
1218 : void *arg1;
1219 : void *arg2;
1220 : void *arg3;
1221 : void *arg4;
1222 : void *arg5;
1223 : efi_status_t status;
1224 : struct work_struct work;
1225 : enum efi_rts_ids efi_rts_id;
1226 : struct completion efi_rts_comp;
1227 : };
1228 :
1229 : extern struct efi_runtime_work efi_rts_work;
1230 :
1231 : /* Workqueue to queue EFI Runtime Services */
1232 : extern struct workqueue_struct *efi_rts_wq;
1233 :
1234 : struct linux_efi_memreserve {
1235 : int size; // allocated size of the array
1236 : atomic_t count; // number of entries used
1237 : phys_addr_t next; // pa of next struct instance
1238 : struct {
1239 : phys_addr_t base;
1240 : phys_addr_t size;
1241 : } entry[];
1242 : };
1243 :
1244 : #define EFI_MEMRESERVE_COUNT(size) (((size) - sizeof(struct linux_efi_memreserve)) \
1245 : / sizeof_field(struct linux_efi_memreserve, entry[0]))
1246 :
1247 : void __init efi_arch_mem_reserve(phys_addr_t addr, u64 size);
1248 :
1249 : char *efi_systab_show_arch(char *str);
1250 :
1251 : /*
1252 : * The LINUX_EFI_MOK_VARIABLE_TABLE_GUID config table can be provided
1253 : * to the kernel by an EFI boot loader. The table contains a packed
1254 : * sequence of these entries, one for each named MOK variable.
1255 : * The sequence is terminated by an entry with a completely NULL
1256 : * name and 0 data size.
1257 : */
1258 : struct efi_mokvar_table_entry {
1259 : char name[256];
1260 : u64 data_size;
1261 : u8 data[];
1262 : } __attribute((packed));
1263 :
1264 : #ifdef CONFIG_LOAD_UEFI_KEYS
1265 : extern void __init efi_mokvar_table_init(void);
1266 : extern struct efi_mokvar_table_entry *efi_mokvar_entry_next(
1267 : struct efi_mokvar_table_entry **mokvar_entry);
1268 : extern struct efi_mokvar_table_entry *efi_mokvar_entry_find(const char *name);
1269 : #else
1270 1 : static inline void efi_mokvar_table_init(void) { }
1271 : static inline struct efi_mokvar_table_entry *efi_mokvar_entry_next(
1272 : struct efi_mokvar_table_entry **mokvar_entry)
1273 : {
1274 : return NULL;
1275 : }
1276 : static inline struct efi_mokvar_table_entry *efi_mokvar_entry_find(
1277 : const char *name)
1278 : {
1279 : return NULL;
1280 : }
1281 : #endif
1282 :
1283 : #endif /* _LINUX_EFI_H */
|
