Commit | Line | Data |
---|---|---|
b2441318 | 1 | /* SPDX-License-Identifier: GPL-2.0 */ |
1965aae3 PA |
2 | #ifndef _ASM_X86_EFI_H |
3 | #define _ASM_X86_EFI_H | |
5b83683f | 4 | |
df6b35f4 | 5 | #include <asm/fpu/api.h> |
9788375d | 6 | #include <asm/processor-flags.h> |
c9f2a9a6 | 7 | #include <asm/tlb.h> |
dd84441a | 8 | #include <asm/nospec-branch.h> |
7e904a91 | 9 | #include <asm/mmu_context.h> |
14b864f4 | 10 | #include <linux/build_bug.h> |
9b47c527 | 11 | #include <linux/kernel.h> |
65fddcfc | 12 | #include <linux/pgtable.h> |
744937b0 | 13 | |
9cd437ac AB |
14 | extern unsigned long efi_fw_vendor, efi_config_table; |
15 | ||
d2f7cbe7 BP |
16 | /* |
17 | * We map the EFI regions needed for runtime services non-contiguously, | |
18 | * with preserved alignment on virtual addresses starting from -4G down | |
19 | * for a total max space of 64G. This way, we provide for stable runtime | |
20 | * services addresses across kernels so that a kexec'd kernel can still | |
21 | * use them. | |
22 | * | |
23 | * This is the main reason why we're doing stable VA mappings for RT | |
24 | * services. | |
d2f7cbe7 | 25 | */ |
d2f7cbe7 | 26 | |
b8ff87a6 MF |
27 | #define EFI32_LOADER_SIGNATURE "EL32" |
28 | #define EFI64_LOADER_SIGNATURE "EL64" | |
29 | ||
9788375d | 30 | #define ARCH_EFI_IRQ_FLAGS_MASK X86_EFLAGS_IF |
e429795c | 31 | |
14b864f4 AS |
32 | /* |
33 | * The EFI services are called through variadic functions in many cases. These | |
34 | * functions are implemented in assembler and support only a fixed number of | |
35 | * arguments. The macros below allows us to check at build time that we don't | |
36 | * try to call them with too many arguments. | |
37 | * | |
38 | * __efi_nargs() will return the number of arguments if it is 7 or less, and | |
39 | * cause a BUILD_BUG otherwise. The limitations of the C preprocessor make it | |
40 | * impossible to calculate the exact number of arguments beyond some | |
41 | * pre-defined limit. The maximum number of arguments currently supported by | |
42 | * any of the thunks is 7, so this is good enough for now and can be extended | |
43 | * in the obvious way if we ever need more. | |
44 | */ | |
45 | ||
46 | #define __efi_nargs(...) __efi_nargs_(__VA_ARGS__) | |
47 | #define __efi_nargs_(...) __efi_nargs__(0, ##__VA_ARGS__, \ | |
48 | __efi_arg_sentinel(7), __efi_arg_sentinel(6), \ | |
49 | __efi_arg_sentinel(5), __efi_arg_sentinel(4), \ | |
50 | __efi_arg_sentinel(3), __efi_arg_sentinel(2), \ | |
51 | __efi_arg_sentinel(1), __efi_arg_sentinel(0)) | |
52 | #define __efi_nargs__(_0, _1, _2, _3, _4, _5, _6, _7, n, ...) \ | |
53 | __take_second_arg(n, \ | |
54 | ({ BUILD_BUG_ON_MSG(1, "__efi_nargs limit exceeded"); 8; })) | |
55 | #define __efi_arg_sentinel(n) , n | |
56 | ||
57 | /* | |
58 | * __efi_nargs_check(f, n, ...) will cause a BUILD_BUG if the ellipsis | |
59 | * represents more than n arguments. | |
60 | */ | |
61 | ||
62 | #define __efi_nargs_check(f, n, ...) \ | |
63 | __efi_nargs_check_(f, __efi_nargs(__VA_ARGS__), n) | |
64 | #define __efi_nargs_check_(f, p, n) __efi_nargs_check__(f, p, n) | |
65 | #define __efi_nargs_check__(f, p, n) ({ \ | |
66 | BUILD_BUG_ON_MSG( \ | |
67 | (p) > (n), \ | |
68 | #f " called with too many arguments (" #p ">" #n ")"); \ | |
69 | }) | |
70 | ||
9788375d | 71 | #ifdef CONFIG_X86_32 |
dd84441a DW |
72 | #define arch_efi_call_virt_setup() \ |
73 | ({ \ | |
74 | kernel_fpu_begin(); \ | |
75 | firmware_restrict_branch_speculation_start(); \ | |
76 | }) | |
77 | ||
78 | #define arch_efi_call_virt_teardown() \ | |
79 | ({ \ | |
80 | firmware_restrict_branch_speculation_end(); \ | |
81 | kernel_fpu_end(); \ | |
82 | }) | |
83 | ||
89ed4865 | 84 | #define arch_efi_call_virt(p, f, args...) p->f(args) |
982e239c | 85 | |
5b83683f HY |
86 | #else /* !CONFIG_X86_32 */ |
87 | ||
62fa6e69 MF |
88 | #define EFI_LOADER_SIGNATURE "EL64" |
89 | ||
14b864f4 AS |
90 | extern asmlinkage u64 __efi_call(void *fp, ...); |
91 | ||
92 | #define efi_call(...) ({ \ | |
93 | __efi_nargs_check(efi_call, 7, __VA_ARGS__); \ | |
94 | __efi_call(__VA_ARGS__); \ | |
95 | }) | |
62fa6e69 | 96 | |
c9f2a9a6 | 97 | /* |
03781e40 SP |
98 | * struct efi_scratch - Scratch space used while switching to/from efi_mm |
99 | * @phys_stack: stack used during EFI Mixed Mode | |
100 | * @prev_mm: store/restore stolen mm_struct while switching to/from efi_mm | |
c9f2a9a6 MF |
101 | */ |
102 | struct efi_scratch { | |
03781e40 SP |
103 | u64 phys_stack; |
104 | struct mm_struct *prev_mm; | |
c9f2a9a6 MF |
105 | } __packed; |
106 | ||
bc25f9db | 107 | #define arch_efi_call_virt_setup() \ |
d2f7cbe7 | 108 | ({ \ |
d2f7cbe7 | 109 | efi_sync_low_kernel_mappings(); \ |
12209993 | 110 | kernel_fpu_begin(); \ |
dd84441a | 111 | firmware_restrict_branch_speculation_start(); \ |
3bcf25a4 | 112 | efi_switch_mm(&efi_mm); \ |
bc25f9db MR |
113 | }) |
114 | ||
80e75596 AT |
115 | #define arch_efi_call_virt(p, f, args...) \ |
116 | efi_call((void *)p->f, args) \ | |
bc25f9db MR |
117 | |
118 | #define arch_efi_call_virt_teardown() \ | |
119 | ({ \ | |
3bcf25a4 | 120 | efi_switch_mm(efi_scratch.prev_mm); \ |
dd84441a | 121 | firmware_restrict_branch_speculation_end(); \ |
12209993 | 122 | kernel_fpu_end(); \ |
d2f7cbe7 BP |
123 | }) |
124 | ||
a523841e | 125 | #ifdef CONFIG_KASAN |
769a8089 AR |
126 | /* |
127 | * CONFIG_KASAN may redefine memset to __memset. __memset function is present | |
128 | * only in kernel binary. Since the EFI stub linked into a separate binary it | |
129 | * doesn't have __memset(). So we should use standard memset from | |
130 | * arch/x86/boot/compressed/string.c. The same applies to memcpy and memmove. | |
131 | */ | |
132 | #undef memcpy | |
133 | #undef memset | |
134 | #undef memmove | |
a523841e | 135 | #endif |
769a8089 | 136 | |
5b83683f HY |
137 | #endif /* CONFIG_X86_32 */ |
138 | ||
d2f7cbe7 | 139 | extern struct efi_scratch efi_scratch; |
4e78eb05 | 140 | extern int __init efi_memblock_x86_reserve_range(void); |
0bbea1ce | 141 | extern void __init efi_print_memmap(void); |
d2f7cbe7 | 142 | extern void __init efi_map_region(efi_memory_desc_t *md); |
3b266496 | 143 | extern void __init efi_map_region_fixed(efi_memory_desc_t *md); |
d2f7cbe7 | 144 | extern void efi_sync_low_kernel_mappings(void); |
67a9108e | 145 | extern int __init efi_alloc_page_tables(void); |
4e78eb05 | 146 | extern int __init efi_setup_page_tables(unsigned long pa_memmap, unsigned num_pages); |
6d0cc887 | 147 | extern void __init efi_runtime_update_mappings(void); |
11cc8512 | 148 | extern void __init efi_dump_pagetable(void); |
a5d90c92 | 149 | extern void __init efi_apply_memmap_quirks(void); |
eeb9db09 ST |
150 | extern int __init efi_reuse_config(u64 tables, int nr_tables); |
151 | extern void efi_delete_dummy_variable(void); | |
03781e40 | 152 | extern void efi_switch_mm(struct mm_struct *mm); |
3425d934 | 153 | extern void efi_recover_from_page_fault(unsigned long phys_addr); |
47c33a09 | 154 | extern void efi_free_boot_services(void); |
5b83683f | 155 | |
a088b858 | 156 | /* kexec external ABI */ |
1fec0533 DY |
157 | struct efi_setup_data { |
158 | u64 fw_vendor; | |
a088b858 | 159 | u64 __unused; |
1fec0533 DY |
160 | u64 tables; |
161 | u64 smbios; | |
162 | u64 reserved[8]; | |
163 | }; | |
164 | ||
165 | extern u64 efi_setup; | |
1fec0533 | 166 | |
6b59e366 | 167 | #ifdef CONFIG_EFI |
14b864f4 AS |
168 | extern efi_status_t __efi64_thunk(u32, ...); |
169 | ||
170 | #define efi64_thunk(...) ({ \ | |
171 | __efi_nargs_check(efi64_thunk, 6, __VA_ARGS__); \ | |
172 | __efi64_thunk(__VA_ARGS__); \ | |
173 | }) | |
6b59e366 | 174 | |
a8147dba | 175 | static inline bool efi_is_mixed(void) |
6b59e366 | 176 | { |
a8147dba AB |
177 | if (!IS_ENABLED(CONFIG_EFI_MIXED)) |
178 | return false; | |
179 | return IS_ENABLED(CONFIG_X86_64) && !efi_enabled(EFI_64BIT); | |
6b59e366 ST |
180 | } |
181 | ||
7d453eee MF |
182 | static inline bool efi_runtime_supported(void) |
183 | { | |
6cfcd6f0 | 184 | if (IS_ENABLED(CONFIG_X86_64) == efi_enabled(EFI_64BIT)) |
7d453eee MF |
185 | return true; |
186 | ||
1f299fad | 187 | return IS_ENABLED(CONFIG_EFI_MIXED); |
7d453eee MF |
188 | } |
189 | ||
5c12af0c | 190 | extern void parse_efi_setup(u64 phys_addr, u32 data_len); |
4f9dbcfc | 191 | |
21289ec0 AB |
192 | extern void efifb_setup_from_dmi(struct screen_info *si, const char *opt); |
193 | ||
4f9dbcfc | 194 | extern void efi_thunk_runtime_setup(void); |
69829470 AB |
195 | efi_status_t efi_set_virtual_address_map(unsigned long memory_map_size, |
196 | unsigned long descriptor_size, | |
197 | u32 descriptor_version, | |
59f2a619 AB |
198 | efi_memory_desc_t *virtual_map, |
199 | unsigned long systab_phys); | |
243b6754 AB |
200 | |
201 | /* arch specific definitions used by the stub code */ | |
202 | ||
de8c5520 AS |
203 | #ifdef CONFIG_EFI_MIXED |
204 | ||
205 | #define ARCH_HAS_EFISTUB_WRAPPERS | |
0a755614 AB |
206 | |
207 | static inline bool efi_is_64bit(void) | |
208 | { | |
de8c5520 AS |
209 | extern const bool efi_is64; |
210 | ||
211 | return efi_is64; | |
0a755614 | 212 | } |
27571616 | 213 | |
f958efe9 AB |
214 | static inline bool efi_is_native(void) |
215 | { | |
f958efe9 AB |
216 | return efi_is_64bit(); |
217 | } | |
218 | ||
219 | #define efi_mixed_mode_cast(attr) \ | |
220 | __builtin_choose_expr( \ | |
221 | __builtin_types_compatible_p(u32, __typeof__(attr)), \ | |
222 | (unsigned long)(attr), (attr)) | |
223 | ||
99ea8b1d AB |
224 | #define efi_table_attr(inst, attr) \ |
225 | (efi_is_native() \ | |
226 | ? inst->attr \ | |
227 | : (__typeof__(inst->attr)) \ | |
228 | efi_mixed_mode_cast(inst->mixed_mode.attr)) | |
3552fdf2 | 229 | |
ea7d87f9 AS |
230 | /* |
231 | * The following macros allow translating arguments if necessary from native to | |
232 | * mixed mode. The use case for this is to initialize the upper 32 bits of | |
233 | * output parameters, and where the 32-bit method requires a 64-bit argument, | |
234 | * which must be split up into two arguments to be thunked properly. | |
235 | * | |
236 | * As examples, the AllocatePool boot service returns the address of the | |
237 | * allocation, but it will not set the high 32 bits of the address. To ensure | |
238 | * that the full 64-bit address is initialized, we zero-init the address before | |
239 | * calling the thunk. | |
240 | * | |
241 | * The FreePages boot service takes a 64-bit physical address even in 32-bit | |
242 | * mode. For the thunk to work correctly, a native 64-bit call of | |
243 | * free_pages(addr, size) | |
244 | * must be translated to | |
245 | * efi64_thunk(free_pages, addr & U32_MAX, addr >> 32, size) | |
246 | * so that the two 32-bit halves of addr get pushed onto the stack separately. | |
247 | */ | |
248 | ||
249 | static inline void *efi64_zero_upper(void *p) | |
250 | { | |
251 | ((u32 *)p)[1] = 0; | |
252 | return p; | |
253 | } | |
254 | ||
3b8f44fc AB |
255 | static inline u32 efi64_convert_status(efi_status_t status) |
256 | { | |
257 | return (u32)(status | (u64)status >> 32); | |
258 | } | |
259 | ||
ea7d87f9 AS |
260 | #define __efi64_argmap_free_pages(addr, size) \ |
261 | ((addr), 0, (size)) | |
262 | ||
263 | #define __efi64_argmap_get_memory_map(mm_size, mm, key, size, ver) \ | |
264 | ((mm_size), (mm), efi64_zero_upper(key), efi64_zero_upper(size), (ver)) | |
265 | ||
266 | #define __efi64_argmap_allocate_pool(type, size, buffer) \ | |
267 | ((type), (size), efi64_zero_upper(buffer)) | |
268 | ||
9b47c527 AS |
269 | #define __efi64_argmap_create_event(type, tpl, f, c, event) \ |
270 | ((type), (tpl), (f), (c), efi64_zero_upper(event)) | |
271 | ||
272 | #define __efi64_argmap_set_timer(event, type, time) \ | |
273 | ((event), (type), lower_32_bits(time), upper_32_bits(time)) | |
274 | ||
275 | #define __efi64_argmap_wait_for_event(num, event, index) \ | |
276 | ((num), (event), efi64_zero_upper(index)) | |
277 | ||
ea7d87f9 AS |
278 | #define __efi64_argmap_handle_protocol(handle, protocol, interface) \ |
279 | ((handle), (protocol), efi64_zero_upper(interface)) | |
280 | ||
281 | #define __efi64_argmap_locate_protocol(protocol, reg, interface) \ | |
282 | ((protocol), (reg), efi64_zero_upper(interface)) | |
283 | ||
abd26868 AB |
284 | #define __efi64_argmap_locate_device_path(protocol, path, handle) \ |
285 | ((protocol), (path), efi64_zero_upper(handle)) | |
286 | ||
3b8f44fc AB |
287 | #define __efi64_argmap_exit(handle, status, size, data) \ |
288 | ((handle), efi64_convert_status(status), (size), (data)) | |
289 | ||
4444f854 MG |
290 | /* PCI I/O */ |
291 | #define __efi64_argmap_get_location(protocol, seg, bus, dev, func) \ | |
292 | ((protocol), efi64_zero_upper(seg), efi64_zero_upper(bus), \ | |
293 | efi64_zero_upper(dev), efi64_zero_upper(func)) | |
294 | ||
2931d526 AB |
295 | /* LoadFile */ |
296 | #define __efi64_argmap_load_file(protocol, path, policy, bufsize, buf) \ | |
297 | ((protocol), (path), (policy), efi64_zero_upper(bufsize), (buf)) | |
298 | ||
b4b89a02 AS |
299 | /* Graphics Output Protocol */ |
300 | #define __efi64_argmap_query_mode(gop, mode, size, info) \ | |
301 | ((gop), (mode), efi64_zero_upper(size), efi64_zero_upper(info)) | |
302 | ||
ea7d87f9 AS |
303 | /* |
304 | * The macros below handle the plumbing for the argument mapping. To add a | |
305 | * mapping for a specific EFI method, simply define a macro | |
306 | * __efi64_argmap_<method name>, following the examples above. | |
307 | */ | |
308 | ||
309 | #define __efi64_thunk_map(inst, func, ...) \ | |
310 | efi64_thunk(inst->mixed_mode.func, \ | |
311 | __efi64_argmap(__efi64_argmap_ ## func(__VA_ARGS__), \ | |
312 | (__VA_ARGS__))) | |
313 | ||
314 | #define __efi64_argmap(mapped, args) \ | |
315 | __PASTE(__efi64_argmap__, __efi_nargs(__efi_eat mapped))(mapped, args) | |
316 | #define __efi64_argmap__0(mapped, args) __efi_eval mapped | |
317 | #define __efi64_argmap__1(mapped, args) __efi_eval args | |
318 | ||
319 | #define __efi_eat(...) | |
320 | #define __efi_eval(...) __VA_ARGS__ | |
321 | ||
322 | /* The three macros below handle dispatching via the thunk if needed */ | |
323 | ||
47c0fd39 | 324 | #define efi_call_proto(inst, func, ...) \ |
afc4cc71 | 325 | (efi_is_native() \ |
47c0fd39 | 326 | ? inst->func(inst, ##__VA_ARGS__) \ |
ea7d87f9 | 327 | : __efi64_thunk_map(inst, func, inst, ##__VA_ARGS__)) |
3552fdf2 | 328 | |
966291f6 | 329 | #define efi_bs_call(func, ...) \ |
afc4cc71 | 330 | (efi_is_native() \ |
ccc27ae7 AB |
331 | ? efi_system_table->boottime->func(__VA_ARGS__) \ |
332 | : __efi64_thunk_map(efi_table_attr(efi_system_table, \ | |
333 | boottime), \ | |
334 | func, __VA_ARGS__)) | |
243b6754 | 335 | |
966291f6 | 336 | #define efi_rt_call(func, ...) \ |
afc4cc71 | 337 | (efi_is_native() \ |
ccc27ae7 AB |
338 | ? efi_system_table->runtime->func(__VA_ARGS__) \ |
339 | : __efi64_thunk_map(efi_table_attr(efi_system_table, \ | |
340 | runtime), \ | |
341 | func, __VA_ARGS__)) | |
a2cd2f3f | 342 | |
de8c5520 AS |
343 | #else /* CONFIG_EFI_MIXED */ |
344 | ||
345 | static inline bool efi_is_64bit(void) | |
346 | { | |
347 | return IS_ENABLED(CONFIG_X86_64); | |
348 | } | |
349 | ||
350 | #endif /* CONFIG_EFI_MIXED */ | |
351 | ||
44be28e9 | 352 | extern bool efi_reboot_required(void); |
e55f31a5 | 353 | extern bool efi_is_table_address(unsigned long phys_addr); |
44be28e9 | 354 | |
6950e31b DW |
355 | extern void efi_find_mirror(void); |
356 | extern void efi_reserve_boot_services(void); | |
6b59e366 | 357 | #else |
5c12af0c | 358 | static inline void parse_efi_setup(u64 phys_addr, u32 data_len) {} |
44be28e9 MF |
359 | static inline bool efi_reboot_required(void) |
360 | { | |
361 | return false; | |
362 | } | |
e55f31a5 AB |
363 | static inline bool efi_is_table_address(unsigned long phys_addr) |
364 | { | |
365 | return false; | |
366 | } | |
6950e31b DW |
367 | static inline void efi_find_mirror(void) |
368 | { | |
369 | } | |
370 | static inline void efi_reserve_boot_services(void) | |
371 | { | |
372 | } | |
7f594232 RA |
373 | #endif /* CONFIG_EFI */ |
374 | ||
199c8471 DW |
375 | #ifdef CONFIG_EFI_FAKE_MEMMAP |
376 | extern void __init efi_fake_memmap_early(void); | |
377 | #else | |
378 | static inline void efi_fake_memmap_early(void) | |
379 | { | |
380 | } | |
381 | #endif | |
382 | ||
25519d68 CL |
383 | #define arch_ima_efi_boot_mode \ |
384 | ({ extern struct boot_params boot_params; boot_params.secure_boot; }) | |
385 | ||
1965aae3 | 386 | #endif /* _ASM_X86_EFI_H */ |