Branch data Line data Source code
1 : : /* SPDX-License-Identifier: GPL-2.0 */
2 : : #ifndef _ASM_X86_EFI_H
3 : : #define _ASM_X86_EFI_H
4 : :
5 : : #include <asm/fpu/api.h>
6 : : #include <asm/pgtable.h>
7 : : #include <asm/processor-flags.h>
8 : : #include <asm/tlb.h>
9 : : #include <asm/nospec-branch.h>
10 : : #include <asm/mmu_context.h>
11 : : #include <linux/build_bug.h>
12 : :
13 : : /*
14 : : * We map the EFI regions needed for runtime services non-contiguously,
15 : : * with preserved alignment on virtual addresses starting from -4G down
16 : : * for a total max space of 64G. This way, we provide for stable runtime
17 : : * services addresses across kernels so that a kexec'd kernel can still
18 : : * use them.
19 : : *
20 : : * This is the main reason why we're doing stable VA mappings for RT
21 : : * services.
22 : : *
23 : : * SGI UV1 machines are known to be incompatible with this scheme, so we
24 : : * provide an opt-out for these machines via a DMI quirk that sets the
25 : : * attribute below.
26 : : */
27 : : #define EFI_UV1_MEMMAP EFI_ARCH_1
28 : :
29 : 0 : static inline bool efi_have_uv1_memmap(void)
30 : : {
31 : 0 : return IS_ENABLED(CONFIG_X86_UV) && efi_enabled(EFI_UV1_MEMMAP);
32 : : }
33 : :
34 : : #define EFI32_LOADER_SIGNATURE "EL32"
35 : : #define EFI64_LOADER_SIGNATURE "EL64"
36 : :
37 : : #define MAX_CMDLINE_ADDRESS UINT_MAX
38 : :
39 : : #define ARCH_EFI_IRQ_FLAGS_MASK X86_EFLAGS_IF
40 : :
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 : :
80 : : #ifdef CONFIG_X86_32
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 : :
93 : :
94 : : #define arch_efi_call_virt(p, f, args...) p->f(args)
95 : :
96 : : #define efi_ioremap(addr, size, type, attr) ioremap_cache(addr, size)
97 : :
98 : : #else /* !CONFIG_X86_32 */
99 : :
100 : : #define EFI_LOADER_SIGNATURE "EL64"
101 : :
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 : : })
108 : :
109 : : /*
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
113 : : */
114 : : struct efi_scratch {
115 : : u64 phys_stack;
116 : : struct mm_struct *prev_mm;
117 : : } __packed;
118 : :
119 : : #define arch_efi_call_virt_setup() \
120 : : ({ \
121 : : efi_sync_low_kernel_mappings(); \
122 : : kernel_fpu_begin(); \
123 : : firmware_restrict_branch_speculation_start(); \
124 : : \
125 : : if (!efi_have_uv1_memmap()) \
126 : : efi_switch_mm(&efi_mm); \
127 : : })
128 : :
129 : : #define arch_efi_call_virt(p, f, args...) \
130 : : efi_call((void *)p->f, args) \
131 : :
132 : : #define arch_efi_call_virt_teardown() \
133 : : ({ \
134 : : if (!efi_have_uv1_memmap()) \
135 : : efi_switch_mm(efi_scratch.prev_mm); \
136 : : \
137 : : firmware_restrict_branch_speculation_end(); \
138 : : kernel_fpu_end(); \
139 : : })
140 : :
141 : : extern void __iomem *__init efi_ioremap(unsigned long addr, unsigned long size,
142 : : u32 type, u64 attribute);
143 : :
144 : : #ifdef CONFIG_KASAN
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
154 : : #endif
155 : :
156 : : #endif /* CONFIG_X86_32 */
157 : :
158 : : extern struct efi_scratch efi_scratch;
159 : : extern void __init efi_set_executable(efi_memory_desc_t *md, bool executable);
160 : : extern int __init efi_memblock_x86_reserve_range(void);
161 : : extern void __init efi_print_memmap(void);
162 : : extern void __init efi_memory_uc(u64 addr, unsigned long size);
163 : : extern void __init efi_map_region(efi_memory_desc_t *md);
164 : : extern void __init efi_map_region_fixed(efi_memory_desc_t *md);
165 : : extern void efi_sync_low_kernel_mappings(void);
166 : : extern int __init efi_alloc_page_tables(void);
167 : : extern int __init efi_setup_page_tables(unsigned long pa_memmap, unsigned num_pages);
168 : : extern void __init old_map_region(efi_memory_desc_t *md);
169 : : extern void __init runtime_code_page_mkexec(void);
170 : : extern void __init efi_runtime_update_mappings(void);
171 : : extern void __init efi_dump_pagetable(void);
172 : : extern void __init efi_apply_memmap_quirks(void);
173 : : extern int __init efi_reuse_config(u64 tables, int nr_tables);
174 : : extern void efi_delete_dummy_variable(void);
175 : : extern void efi_switch_mm(struct mm_struct *mm);
176 : : extern void efi_recover_from_page_fault(unsigned long phys_addr);
177 : : extern void efi_free_boot_services(void);
178 : : extern pgd_t * __init efi_uv1_memmap_phys_prolog(void);
179 : : extern void __init efi_uv1_memmap_phys_epilog(pgd_t *save_pgd);
180 : :
181 : : struct efi_setup_data {
182 : : u64 fw_vendor;
183 : : u64 runtime;
184 : : u64 tables;
185 : : u64 smbios;
186 : : u64 reserved[8];
187 : : };
188 : :
189 : : extern u64 efi_setup;
190 : :
191 : : #ifdef CONFIG_EFI
192 : : extern efi_status_t __efi64_thunk(u32, ...);
193 : :
194 : : #define efi64_thunk(...) ({ \
195 : : __efi_nargs_check(efi64_thunk, 6, __VA_ARGS__); \
196 : : __efi64_thunk(__VA_ARGS__); \
197 : : })
198 : :
199 : : static inline bool efi_is_mixed(void)
200 : : {
201 : : if (!IS_ENABLED(CONFIG_EFI_MIXED))
202 : : return false;
203 : : return IS_ENABLED(CONFIG_X86_64) && !efi_enabled(EFI_64BIT);
204 : : }
205 : :
206 : : static inline bool efi_runtime_supported(void)
207 : : {
208 : : if (IS_ENABLED(CONFIG_X86_64) == efi_enabled(EFI_64BIT))
209 : : return true;
210 : :
211 : : return IS_ENABLED(CONFIG_EFI_MIXED);
212 : : }
213 : :
214 : : extern void parse_efi_setup(u64 phys_addr, u32 data_len);
215 : :
216 : : extern void efifb_setup_from_dmi(struct screen_info *si, const char *opt);
217 : :
218 : : extern void efi_thunk_runtime_setup(void);
219 : : efi_status_t efi_set_virtual_address_map(unsigned long memory_map_size,
220 : : unsigned long descriptor_size,
221 : : u32 descriptor_version,
222 : : efi_memory_desc_t *virtual_map);
223 : :
224 : : /* arch specific definitions used by the stub code */
225 : :
226 : : __attribute_const__ bool efi_is_64bit(void);
227 : :
228 : : static inline bool efi_is_native(void)
229 : : {
230 : : if (!IS_ENABLED(CONFIG_X86_64))
231 : : return true;
232 : : if (!IS_ENABLED(CONFIG_EFI_MIXED))
233 : : return true;
234 : : return efi_is_64bit();
235 : : }
236 : :
237 : : #define efi_mixed_mode_cast(attr) \
238 : : __builtin_choose_expr( \
239 : : __builtin_types_compatible_p(u32, __typeof__(attr)), \
240 : : (unsigned long)(attr), (attr))
241 : :
242 : : #define efi_table_attr(inst, attr) \
243 : : (efi_is_native() \
244 : : ? inst->attr \
245 : : : (__typeof__(inst->attr)) \
246 : : efi_mixed_mode_cast(inst->mixed_mode.attr))
247 : :
248 : : /*
249 : : * The following macros allow translating arguments if necessary from native to
250 : : * mixed mode. The use case for this is to initialize the upper 32 bits of
251 : : * output parameters, and where the 32-bit method requires a 64-bit argument,
252 : : * which must be split up into two arguments to be thunked properly.
253 : : *
254 : : * As examples, the AllocatePool boot service returns the address of the
255 : : * allocation, but it will not set the high 32 bits of the address. To ensure
256 : : * that the full 64-bit address is initialized, we zero-init the address before
257 : : * calling the thunk.
258 : : *
259 : : * The FreePages boot service takes a 64-bit physical address even in 32-bit
260 : : * mode. For the thunk to work correctly, a native 64-bit call of
261 : : * free_pages(addr, size)
262 : : * must be translated to
263 : : * efi64_thunk(free_pages, addr & U32_MAX, addr >> 32, size)
264 : : * so that the two 32-bit halves of addr get pushed onto the stack separately.
265 : : */
266 : :
267 : : static inline void *efi64_zero_upper(void *p)
268 : : {
269 : : ((u32 *)p)[1] = 0;
270 : : return p;
271 : : }
272 : :
273 : : #define __efi64_argmap_free_pages(addr, size) \
274 : : ((addr), 0, (size))
275 : :
276 : : #define __efi64_argmap_get_memory_map(mm_size, mm, key, size, ver) \
277 : : ((mm_size), (mm), efi64_zero_upper(key), efi64_zero_upper(size), (ver))
278 : :
279 : : #define __efi64_argmap_allocate_pool(type, size, buffer) \
280 : : ((type), (size), efi64_zero_upper(buffer))
281 : :
282 : : #define __efi64_argmap_handle_protocol(handle, protocol, interface) \
283 : : ((handle), (protocol), efi64_zero_upper(interface))
284 : :
285 : : #define __efi64_argmap_locate_protocol(protocol, reg, interface) \
286 : : ((protocol), (reg), efi64_zero_upper(interface))
287 : :
288 : : /* PCI I/O */
289 : : #define __efi64_argmap_get_location(protocol, seg, bus, dev, func) \
290 : : ((protocol), efi64_zero_upper(seg), efi64_zero_upper(bus), \
291 : : efi64_zero_upper(dev), efi64_zero_upper(func))
292 : :
293 : : /*
294 : : * The macros below handle the plumbing for the argument mapping. To add a
295 : : * mapping for a specific EFI method, simply define a macro
296 : : * __efi64_argmap_<method name>, following the examples above.
297 : : */
298 : :
299 : : #define __efi64_thunk_map(inst, func, ...) \
300 : : efi64_thunk(inst->mixed_mode.func, \
301 : : __efi64_argmap(__efi64_argmap_ ## func(__VA_ARGS__), \
302 : : (__VA_ARGS__)))
303 : :
304 : : #define __efi64_argmap(mapped, args) \
305 : : __PASTE(__efi64_argmap__, __efi_nargs(__efi_eat mapped))(mapped, args)
306 : : #define __efi64_argmap__0(mapped, args) __efi_eval mapped
307 : : #define __efi64_argmap__1(mapped, args) __efi_eval args
308 : :
309 : : #define __efi_eat(...)
310 : : #define __efi_eval(...) __VA_ARGS__
311 : :
312 : : /* The three macros below handle dispatching via the thunk if needed */
313 : :
314 : : #define efi_call_proto(inst, func, ...) \
315 : : (efi_is_native() \
316 : : ? inst->func(inst, ##__VA_ARGS__) \
317 : : : __efi64_thunk_map(inst, func, inst, ##__VA_ARGS__))
318 : :
319 : : #define efi_bs_call(func, ...) \
320 : : (efi_is_native() \
321 : : ? efi_system_table()->boottime->func(__VA_ARGS__) \
322 : : : __efi64_thunk_map(efi_table_attr(efi_system_table(), \
323 : : boottime), func, __VA_ARGS__))
324 : :
325 : : #define efi_rt_call(func, ...) \
326 : : (efi_is_native() \
327 : : ? efi_system_table()->runtime->func(__VA_ARGS__) \
328 : : : __efi64_thunk_map(efi_table_attr(efi_system_table(), \
329 : : runtime), func, __VA_ARGS__))
330 : :
331 : : extern bool efi_reboot_required(void);
332 : : extern bool efi_is_table_address(unsigned long phys_addr);
333 : :
334 : : extern void efi_find_mirror(void);
335 : : extern void efi_reserve_boot_services(void);
336 : : #else
337 : : static inline void parse_efi_setup(u64 phys_addr, u32 data_len) {}
338 : : static inline bool efi_reboot_required(void)
339 : : {
340 : : return false;
341 : : }
342 : : static inline bool efi_is_table_address(unsigned long phys_addr)
343 : : {
344 : : return false;
345 : : }
346 : : static inline void efi_find_mirror(void)
347 : : {
348 : : }
349 : : static inline void efi_reserve_boot_services(void)
350 : : {
351 : : }
352 : : #endif /* CONFIG_EFI */
353 : :
354 : : #ifdef CONFIG_EFI_FAKE_MEMMAP
355 : : extern void __init efi_fake_memmap_early(void);
356 : : #else
357 : : static inline void efi_fake_memmap_early(void)
358 : : {
359 : : }
360 : : #endif
361 : :
362 : : #endif /* _ASM_X86_EFI_H */
|
