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> |
fe379fa4 | 10 | #include <asm/ibt.h> |
14b864f4 | 11 | #include <linux/build_bug.h> |
9b47c527 | 12 | #include <linux/kernel.h> |
65fddcfc | 13 | #include <linux/pgtable.h> |
744937b0 | 14 | |
9cd437ac | 15 | extern unsigned long efi_fw_vendor, efi_config_table; |
3e1e00c0 | 16 | extern unsigned long efi_mixed_mode_stack_pa; |
9cd437ac | 17 | |
d2f7cbe7 BP |
18 | /* |
19 | * We map the EFI regions needed for runtime services non-contiguously, | |
20 | * with preserved alignment on virtual addresses starting from -4G down | |
21 | * for a total max space of 64G. This way, we provide for stable runtime | |
22 | * services addresses across kernels so that a kexec'd kernel can still | |
23 | * use them. | |
24 | * | |
25 | * This is the main reason why we're doing stable VA mappings for RT | |
26 | * services. | |
d2f7cbe7 | 27 | */ |
d2f7cbe7 | 28 | |
b8ff87a6 MF |
29 | #define EFI32_LOADER_SIGNATURE "EL32" |
30 | #define EFI64_LOADER_SIGNATURE "EL64" | |
31 | ||
9788375d | 32 | #define ARCH_EFI_IRQ_FLAGS_MASK X86_EFLAGS_IF |
e429795c | 33 | |
14b864f4 AS |
34 | /* |
35 | * The EFI services are called through variadic functions in many cases. These | |
36 | * functions are implemented in assembler and support only a fixed number of | |
37 | * arguments. The macros below allows us to check at build time that we don't | |
38 | * try to call them with too many arguments. | |
39 | * | |
40 | * __efi_nargs() will return the number of arguments if it is 7 or less, and | |
41 | * cause a BUILD_BUG otherwise. The limitations of the C preprocessor make it | |
42 | * impossible to calculate the exact number of arguments beyond some | |
43 | * pre-defined limit. The maximum number of arguments currently supported by | |
44 | * any of the thunks is 7, so this is good enough for now and can be extended | |
45 | * in the obvious way if we ever need more. | |
46 | */ | |
47 | ||
48 | #define __efi_nargs(...) __efi_nargs_(__VA_ARGS__) | |
49 | #define __efi_nargs_(...) __efi_nargs__(0, ##__VA_ARGS__, \ | |
44f155b4 | 50 | __efi_arg_sentinel(9), __efi_arg_sentinel(8), \ |
14b864f4 AS |
51 | __efi_arg_sentinel(7), __efi_arg_sentinel(6), \ |
52 | __efi_arg_sentinel(5), __efi_arg_sentinel(4), \ | |
53 | __efi_arg_sentinel(3), __efi_arg_sentinel(2), \ | |
54 | __efi_arg_sentinel(1), __efi_arg_sentinel(0)) | |
44f155b4 | 55 | #define __efi_nargs__(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, n, ...) \ |
14b864f4 | 56 | __take_second_arg(n, \ |
44f155b4 | 57 | ({ BUILD_BUG_ON_MSG(1, "__efi_nargs limit exceeded"); 10; })) |
14b864f4 AS |
58 | #define __efi_arg_sentinel(n) , n |
59 | ||
60 | /* | |
61 | * __efi_nargs_check(f, n, ...) will cause a BUILD_BUG if the ellipsis | |
62 | * represents more than n arguments. | |
63 | */ | |
64 | ||
65 | #define __efi_nargs_check(f, n, ...) \ | |
66 | __efi_nargs_check_(f, __efi_nargs(__VA_ARGS__), n) | |
67 | #define __efi_nargs_check_(f, p, n) __efi_nargs_check__(f, p, n) | |
68 | #define __efi_nargs_check__(f, p, n) ({ \ | |
69 | BUILD_BUG_ON_MSG( \ | |
70 | (p) > (n), \ | |
71 | #f " called with too many arguments (" #p ">" #n ")"); \ | |
72 | }) | |
73 | ||
b0dc553c AL |
74 | static inline void efi_fpu_begin(void) |
75 | { | |
76 | /* | |
77 | * The UEFI calling convention (UEFI spec 2.3.2 and 2.3.4) requires | |
78 | * that FCW and MXCSR (64-bit) must be initialized prior to calling | |
79 | * UEFI code. (Oddly the spec does not require that the FPU stack | |
80 | * be empty.) | |
81 | */ | |
82 | kernel_fpu_begin_mask(KFPU_387 | KFPU_MXCSR); | |
83 | } | |
84 | ||
85 | static inline void efi_fpu_end(void) | |
86 | { | |
87 | kernel_fpu_end(); | |
88 | } | |
89 | ||
9788375d | 90 | #ifdef CONFIG_X86_32 |
dd84441a DW |
91 | #define arch_efi_call_virt_setup() \ |
92 | ({ \ | |
b0dc553c | 93 | efi_fpu_begin(); \ |
dd84441a DW |
94 | firmware_restrict_branch_speculation_start(); \ |
95 | }) | |
96 | ||
97 | #define arch_efi_call_virt_teardown() \ | |
98 | ({ \ | |
99 | firmware_restrict_branch_speculation_end(); \ | |
b0dc553c | 100 | efi_fpu_end(); \ |
dd84441a DW |
101 | }) |
102 | ||
5b83683f HY |
103 | #else /* !CONFIG_X86_32 */ |
104 | ||
62fa6e69 MF |
105 | #define EFI_LOADER_SIGNATURE "EL64" |
106 | ||
14b864f4 AS |
107 | extern asmlinkage u64 __efi_call(void *fp, ...); |
108 | ||
109 | #define efi_call(...) ({ \ | |
110 | __efi_nargs_check(efi_call, 7, __VA_ARGS__); \ | |
111 | __efi_call(__VA_ARGS__); \ | |
112 | }) | |
62fa6e69 | 113 | |
bc25f9db | 114 | #define arch_efi_call_virt_setup() \ |
d2f7cbe7 | 115 | ({ \ |
d2f7cbe7 | 116 | efi_sync_low_kernel_mappings(); \ |
b0dc553c | 117 | efi_fpu_begin(); \ |
dd84441a | 118 | firmware_restrict_branch_speculation_start(); \ |
514b1a84 | 119 | efi_enter_mm(); \ |
bc25f9db MR |
120 | }) |
121 | ||
8add9a3a | 122 | #undef arch_efi_call_virt |
fe379fa4 PZ |
123 | #define arch_efi_call_virt(p, f, args...) ({ \ |
124 | u64 ret, ibt = ibt_save(); \ | |
125 | ret = efi_call((void *)p->f, args); \ | |
126 | ibt_restore(ibt); \ | |
127 | ret; \ | |
128 | }) | |
bc25f9db MR |
129 | |
130 | #define arch_efi_call_virt_teardown() \ | |
131 | ({ \ | |
514b1a84 | 132 | efi_leave_mm(); \ |
dd84441a | 133 | firmware_restrict_branch_speculation_end(); \ |
b0dc553c | 134 | efi_fpu_end(); \ |
d2f7cbe7 BP |
135 | }) |
136 | ||
a523841e | 137 | #ifdef CONFIG_KASAN |
769a8089 AR |
138 | /* |
139 | * CONFIG_KASAN may redefine memset to __memset. __memset function is present | |
140 | * only in kernel binary. Since the EFI stub linked into a separate binary it | |
141 | * doesn't have __memset(). So we should use standard memset from | |
142 | * arch/x86/boot/compressed/string.c. The same applies to memcpy and memmove. | |
143 | */ | |
144 | #undef memcpy | |
145 | #undef memset | |
146 | #undef memmove | |
a523841e | 147 | #endif |
769a8089 | 148 | |
5b83683f HY |
149 | #endif /* CONFIG_X86_32 */ |
150 | ||
4e78eb05 | 151 | extern int __init efi_memblock_x86_reserve_range(void); |
0bbea1ce | 152 | extern void __init efi_print_memmap(void); |
d2f7cbe7 | 153 | extern void __init efi_map_region(efi_memory_desc_t *md); |
3b266496 | 154 | extern void __init efi_map_region_fixed(efi_memory_desc_t *md); |
d2f7cbe7 | 155 | extern void efi_sync_low_kernel_mappings(void); |
67a9108e | 156 | extern int __init efi_alloc_page_tables(void); |
4e78eb05 | 157 | extern int __init efi_setup_page_tables(unsigned long pa_memmap, unsigned num_pages); |
6d0cc887 | 158 | extern void __init efi_runtime_update_mappings(void); |
11cc8512 | 159 | extern void __init efi_dump_pagetable(void); |
a5d90c92 | 160 | extern void __init efi_apply_memmap_quirks(void); |
eeb9db09 ST |
161 | extern int __init efi_reuse_config(u64 tables, int nr_tables); |
162 | extern void efi_delete_dummy_variable(void); | |
c46f5223 | 163 | extern void efi_crash_gracefully_on_page_fault(unsigned long phys_addr); |
47c33a09 | 164 | extern void efi_free_boot_services(void); |
5b83683f | 165 | |
514b1a84 AB |
166 | void efi_enter_mm(void); |
167 | void efi_leave_mm(void); | |
168 | ||
a088b858 | 169 | /* kexec external ABI */ |
1fec0533 DY |
170 | struct efi_setup_data { |
171 | u64 fw_vendor; | |
a088b858 | 172 | u64 __unused; |
1fec0533 DY |
173 | u64 tables; |
174 | u64 smbios; | |
175 | u64 reserved[8]; | |
176 | }; | |
177 | ||
178 | extern u64 efi_setup; | |
1fec0533 | 179 | |
6b59e366 | 180 | #ifdef CONFIG_EFI |
a61962d8 | 181 | extern u64 __efi64_thunk(u32, ...); |
14b864f4 AS |
182 | |
183 | #define efi64_thunk(...) ({ \ | |
44f155b4 AB |
184 | u64 __pad[3]; /* must have space for 3 args on the stack */ \ |
185 | __efi_nargs_check(efi64_thunk, 9, __VA_ARGS__); \ | |
186 | __efi64_thunk(__VA_ARGS__, __pad); \ | |
14b864f4 | 187 | }) |
6b59e366 | 188 | |
a8147dba | 189 | static inline bool efi_is_mixed(void) |
6b59e366 | 190 | { |
a8147dba AB |
191 | if (!IS_ENABLED(CONFIG_EFI_MIXED)) |
192 | return false; | |
193 | return IS_ENABLED(CONFIG_X86_64) && !efi_enabled(EFI_64BIT); | |
6b59e366 ST |
194 | } |
195 | ||
7d453eee MF |
196 | static inline bool efi_runtime_supported(void) |
197 | { | |
6cfcd6f0 | 198 | if (IS_ENABLED(CONFIG_X86_64) == efi_enabled(EFI_64BIT)) |
7d453eee MF |
199 | return true; |
200 | ||
1f299fad | 201 | return IS_ENABLED(CONFIG_EFI_MIXED); |
7d453eee MF |
202 | } |
203 | ||
5c12af0c | 204 | extern void parse_efi_setup(u64 phys_addr, u32 data_len); |
4f9dbcfc | 205 | |
4f9dbcfc | 206 | extern void efi_thunk_runtime_setup(void); |
69829470 AB |
207 | efi_status_t efi_set_virtual_address_map(unsigned long memory_map_size, |
208 | unsigned long descriptor_size, | |
209 | u32 descriptor_version, | |
59f2a619 AB |
210 | efi_memory_desc_t *virtual_map, |
211 | unsigned long systab_phys); | |
243b6754 AB |
212 | |
213 | /* arch specific definitions used by the stub code */ | |
214 | ||
de8c5520 AS |
215 | #ifdef CONFIG_EFI_MIXED |
216 | ||
217 | #define ARCH_HAS_EFISTUB_WRAPPERS | |
0a755614 AB |
218 | |
219 | static inline bool efi_is_64bit(void) | |
220 | { | |
de8c5520 AS |
221 | extern const bool efi_is64; |
222 | ||
223 | return efi_is64; | |
0a755614 | 224 | } |
27571616 | 225 | |
f958efe9 AB |
226 | static inline bool efi_is_native(void) |
227 | { | |
f958efe9 AB |
228 | return efi_is_64bit(); |
229 | } | |
230 | ||
99ea8b1d | 231 | #define efi_table_attr(inst, attr) \ |
a61962d8 AB |
232 | (efi_is_native() ? (inst)->attr \ |
233 | : efi_mixed_table_attr((inst), attr)) | |
234 | ||
235 | #define efi_mixed_table_attr(inst, attr) \ | |
236 | (__typeof__(inst->attr)) \ | |
237 | _Generic(inst->mixed_mode.attr, \ | |
238 | u32: (unsigned long)(inst->mixed_mode.attr), \ | |
239 | default: (inst->mixed_mode.attr)) | |
3552fdf2 | 240 | |
ea7d87f9 AS |
241 | /* |
242 | * The following macros allow translating arguments if necessary from native to | |
243 | * mixed mode. The use case for this is to initialize the upper 32 bits of | |
244 | * output parameters, and where the 32-bit method requires a 64-bit argument, | |
245 | * which must be split up into two arguments to be thunked properly. | |
246 | * | |
247 | * As examples, the AllocatePool boot service returns the address of the | |
248 | * allocation, but it will not set the high 32 bits of the address. To ensure | |
249 | * that the full 64-bit address is initialized, we zero-init the address before | |
250 | * calling the thunk. | |
251 | * | |
252 | * The FreePages boot service takes a 64-bit physical address even in 32-bit | |
253 | * mode. For the thunk to work correctly, a native 64-bit call of | |
254 | * free_pages(addr, size) | |
255 | * must be translated to | |
256 | * efi64_thunk(free_pages, addr & U32_MAX, addr >> 32, size) | |
257 | * so that the two 32-bit halves of addr get pushed onto the stack separately. | |
258 | */ | |
259 | ||
260 | static inline void *efi64_zero_upper(void *p) | |
261 | { | |
262 | ((u32 *)p)[1] = 0; | |
263 | return p; | |
264 | } | |
265 | ||
3b8f44fc AB |
266 | static inline u32 efi64_convert_status(efi_status_t status) |
267 | { | |
268 | return (u32)(status | (u64)status >> 32); | |
269 | } | |
270 | ||
31f1a0ed AB |
271 | #define __efi64_split(val) (val) & U32_MAX, (u64)(val) >> 32 |
272 | ||
ea7d87f9 AS |
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 | ||
9b47c527 AS |
282 | #define __efi64_argmap_create_event(type, tpl, f, c, event) \ |
283 | ((type), (tpl), (f), (c), efi64_zero_upper(event)) | |
284 | ||
285 | #define __efi64_argmap_set_timer(event, type, time) \ | |
286 | ((event), (type), lower_32_bits(time), upper_32_bits(time)) | |
287 | ||
288 | #define __efi64_argmap_wait_for_event(num, event, index) \ | |
289 | ((num), (event), efi64_zero_upper(index)) | |
290 | ||
ea7d87f9 AS |
291 | #define __efi64_argmap_handle_protocol(handle, protocol, interface) \ |
292 | ((handle), (protocol), efi64_zero_upper(interface)) | |
293 | ||
294 | #define __efi64_argmap_locate_protocol(protocol, reg, interface) \ | |
295 | ((protocol), (reg), efi64_zero_upper(interface)) | |
296 | ||
abd26868 AB |
297 | #define __efi64_argmap_locate_device_path(protocol, path, handle) \ |
298 | ((protocol), (path), efi64_zero_upper(handle)) | |
299 | ||
3b8f44fc AB |
300 | #define __efi64_argmap_exit(handle, status, size, data) \ |
301 | ((handle), efi64_convert_status(status), (size), (data)) | |
302 | ||
4444f854 MG |
303 | /* PCI I/O */ |
304 | #define __efi64_argmap_get_location(protocol, seg, bus, dev, func) \ | |
305 | ((protocol), efi64_zero_upper(seg), efi64_zero_upper(bus), \ | |
306 | efi64_zero_upper(dev), efi64_zero_upper(func)) | |
307 | ||
2931d526 AB |
308 | /* LoadFile */ |
309 | #define __efi64_argmap_load_file(protocol, path, policy, bufsize, buf) \ | |
310 | ((protocol), (path), (policy), efi64_zero_upper(bufsize), (buf)) | |
311 | ||
b4b89a02 AS |
312 | /* Graphics Output Protocol */ |
313 | #define __efi64_argmap_query_mode(gop, mode, size, info) \ | |
314 | ((gop), (mode), efi64_zero_upper(size), efi64_zero_upper(info)) | |
315 | ||
4da87c51 AB |
316 | /* TCG2 protocol */ |
317 | #define __efi64_argmap_hash_log_extend_event(prot, fl, addr, size, ev) \ | |
318 | ((prot), (fl), 0ULL, (u64)(addr), 0ULL, (u64)(size), 0ULL, ev) | |
319 | ||
31f1a0ed AB |
320 | /* DXE services */ |
321 | #define __efi64_argmap_get_memory_space_descriptor(phys, desc) \ | |
322 | (__efi64_split(phys), (desc)) | |
323 | ||
aa6d1ed1 | 324 | #define __efi64_argmap_set_memory_space_attributes(phys, size, flags) \ |
31f1a0ed AB |
325 | (__efi64_split(phys), __efi64_split(size), __efi64_split(flags)) |
326 | ||
f8a31244 AB |
327 | /* file protocol */ |
328 | #define __efi64_argmap_open(prot, newh, fname, mode, attr) \ | |
329 | ((prot), efi64_zero_upper(newh), (fname), __efi64_split(mode), \ | |
330 | __efi64_split(attr)) | |
331 | ||
332 | #define __efi64_argmap_set_position(pos) (__efi64_split(pos)) | |
333 | ||
334 | /* file system protocol */ | |
335 | #define __efi64_argmap_open_volume(prot, file) \ | |
336 | ((prot), efi64_zero_upper(file)) | |
337 | ||
79729f26 EB |
338 | /* Memory Attribute Protocol */ |
339 | #define __efi64_argmap_set_memory_attributes(protocol, phys, size, flags) \ | |
340 | ((protocol), __efi64_split(phys), __efi64_split(size), __efi64_split(flags)) | |
341 | ||
342 | #define __efi64_argmap_clear_memory_attributes(protocol, phys, size, flags) \ | |
343 | ((protocol), __efi64_split(phys), __efi64_split(size), __efi64_split(flags)) | |
344 | ||
ea7d87f9 AS |
345 | /* |
346 | * The macros below handle the plumbing for the argument mapping. To add a | |
347 | * mapping for a specific EFI method, simply define a macro | |
348 | * __efi64_argmap_<method name>, following the examples above. | |
349 | */ | |
350 | ||
351 | #define __efi64_thunk_map(inst, func, ...) \ | |
352 | efi64_thunk(inst->mixed_mode.func, \ | |
353 | __efi64_argmap(__efi64_argmap_ ## func(__VA_ARGS__), \ | |
354 | (__VA_ARGS__))) | |
355 | ||
356 | #define __efi64_argmap(mapped, args) \ | |
357 | __PASTE(__efi64_argmap__, __efi_nargs(__efi_eat mapped))(mapped, args) | |
358 | #define __efi64_argmap__0(mapped, args) __efi_eval mapped | |
359 | #define __efi64_argmap__1(mapped, args) __efi_eval args | |
360 | ||
361 | #define __efi_eat(...) | |
362 | #define __efi_eval(...) __VA_ARGS__ | |
363 | ||
a61962d8 AB |
364 | static inline efi_status_t __efi64_widen_efi_status(u64 status) |
365 | { | |
366 | /* use rotate to move the value of bit #31 into position #63 */ | |
367 | return ror64(rol32(status, 1), 1); | |
368 | } | |
369 | ||
370 | /* The macro below handles dispatching via the thunk if needed */ | |
371 | ||
372 | #define efi_fn_call(inst, func, ...) \ | |
373 | (efi_is_native() ? (inst)->func(__VA_ARGS__) \ | |
374 | : efi_mixed_call((inst), func, ##__VA_ARGS__)) | |
375 | ||
376 | #define efi_mixed_call(inst, func, ...) \ | |
377 | _Generic(inst->func(__VA_ARGS__), \ | |
378 | efi_status_t: \ | |
379 | __efi64_widen_efi_status( \ | |
380 | __efi64_thunk_map(inst, func, ##__VA_ARGS__)), \ | |
381 | u64: ({ BUILD_BUG(); ULONG_MAX; }), \ | |
382 | default: \ | |
383 | (__typeof__(inst->func(__VA_ARGS__))) \ | |
384 | __efi64_thunk_map(inst, func, ##__VA_ARGS__)) | |
3ba75c13 | 385 | |
de8c5520 AS |
386 | #else /* CONFIG_EFI_MIXED */ |
387 | ||
388 | static inline bool efi_is_64bit(void) | |
389 | { | |
390 | return IS_ENABLED(CONFIG_X86_64); | |
391 | } | |
392 | ||
393 | #endif /* CONFIG_EFI_MIXED */ | |
394 | ||
44be28e9 | 395 | extern bool efi_reboot_required(void); |
e55f31a5 | 396 | extern bool efi_is_table_address(unsigned long phys_addr); |
44be28e9 | 397 | |
6950e31b | 398 | extern void efi_reserve_boot_services(void); |
6b59e366 | 399 | #else |
5c12af0c | 400 | static inline void parse_efi_setup(u64 phys_addr, u32 data_len) {} |
44be28e9 MF |
401 | static inline bool efi_reboot_required(void) |
402 | { | |
403 | return false; | |
404 | } | |
e55f31a5 AB |
405 | static inline bool efi_is_table_address(unsigned long phys_addr) |
406 | { | |
407 | return false; | |
408 | } | |
6950e31b DW |
409 | static inline void efi_reserve_boot_services(void) |
410 | { | |
411 | } | |
7f594232 RA |
412 | #endif /* CONFIG_EFI */ |
413 | ||
199c8471 DW |
414 | #ifdef CONFIG_EFI_FAKE_MEMMAP |
415 | extern void __init efi_fake_memmap_early(void); | |
4059ba65 | 416 | extern void __init efi_fake_memmap(void); |
199c8471 DW |
417 | #else |
418 | static inline void efi_fake_memmap_early(void) | |
419 | { | |
420 | } | |
4059ba65 AB |
421 | |
422 | static inline void efi_fake_memmap(void) | |
423 | { | |
424 | } | |
199c8471 DW |
425 | #endif |
426 | ||
fdc6d38d AB |
427 | extern int __init efi_memmap_alloc(unsigned int num_entries, |
428 | struct efi_memory_map_data *data); | |
429 | extern void __efi_memmap_free(u64 phys, unsigned long size, | |
430 | unsigned long flags); | |
431 | #define __efi_memmap_free __efi_memmap_free | |
432 | ||
433 | extern int __init efi_memmap_install(struct efi_memory_map_data *data); | |
434 | extern int __init efi_memmap_split_count(efi_memory_desc_t *md, | |
435 | struct range *range); | |
436 | extern void __init efi_memmap_insert(struct efi_memory_map *old_memmap, | |
437 | void *buf, struct efi_mem_range *mem); | |
438 | ||
25519d68 CL |
439 | #define arch_ima_efi_boot_mode \ |
440 | ({ extern struct boot_params boot_params; boot_params.secure_boot; }) | |
441 | ||
1fff234d AB |
442 | #ifdef CONFIG_EFI_RUNTIME_MAP |
443 | int efi_get_runtime_map_size(void); | |
444 | int efi_get_runtime_map_desc_size(void); | |
445 | int efi_runtime_map_copy(void *buf, size_t bufsz); | |
446 | #else | |
447 | static inline int efi_get_runtime_map_size(void) | |
448 | { | |
449 | return 0; | |
450 | } | |
451 | ||
452 | static inline int efi_get_runtime_map_desc_size(void) | |
453 | { | |
454 | return 0; | |
455 | } | |
456 | ||
457 | static inline int efi_runtime_map_copy(void *buf, size_t bufsz) | |
458 | { | |
459 | return 0; | |
460 | } | |
461 | ||
462 | #endif | |
463 | ||
1965aae3 | 464 | #endif /* _ASM_X86_EFI_H */ |