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