2 * x86_64 specific EFI support functions
3 * Based on Extensible Firmware Interface Specification version 1.0
5 * Copyright (C) 2005-2008 Intel Co.
6 * Fenghua Yu <fenghua.yu@intel.com>
7 * Bibo Mao <bibo.mao@intel.com>
8 * Chandramouli Narayanan <mouli@linux.intel.com>
9 * Huang Ying <ying.huang@intel.com>
11 * Code to convert EFI to E820 map has been implemented in elilo bootloader
12 * based on a EFI patch by Edgar Hucek. Based on the E820 map, the page table
13 * is setup appropriately for EFI runtime code.
18 #define pr_fmt(fmt) "efi: " fmt
20 #include <linux/kernel.h>
21 #include <linux/init.h>
23 #include <linux/types.h>
24 #include <linux/spinlock.h>
25 #include <linux/bootmem.h>
26 #include <linux/ioport.h>
27 #include <linux/module.h>
28 #include <linux/efi.h>
29 #include <linux/uaccess.h>
31 #include <linux/reboot.h>
32 #include <linux/slab.h>
34 #include <asm/setup.h>
37 #include <asm/pgtable.h>
38 #include <asm/tlbflush.h>
39 #include <asm/proto.h>
41 #include <asm/cacheflush.h>
42 #include <asm/fixmap.h>
43 #include <asm/realmode.h>
45 #include <asm/pgalloc.h>
48 * We allocate runtime services regions bottom-up, starting from -4G, i.e.
49 * 0xffff_ffff_0000_0000 and limit EFI VA mapping space to 64G.
51 static u64 efi_va
= EFI_VA_START
;
53 struct efi_scratch efi_scratch
;
55 static void __init
early_code_mapping_set_exec(int executable
)
57 efi_memory_desc_t
*md
;
59 if (!(__supported_pte_mask
& _PAGE_NX
))
62 /* Make EFI service code area executable */
63 for_each_efi_memory_desc(md
) {
64 if (md
->type
== EFI_RUNTIME_SERVICES_CODE
||
65 md
->type
== EFI_BOOT_SERVICES_CODE
)
66 efi_set_executable(md
, executable
);
70 pgd_t
* __init
efi_call_phys_prolog(void)
72 unsigned long vaddress
;
78 if (!efi_enabled(EFI_OLD_MEMMAP
)) {
79 save_pgd
= (pgd_t
*)read_cr3();
80 write_cr3((unsigned long)efi_scratch
.efi_pgt
);
84 early_code_mapping_set_exec(1);
86 n_pgds
= DIV_ROUND_UP((max_pfn
<< PAGE_SHIFT
), PGDIR_SIZE
);
87 save_pgd
= kmalloc(n_pgds
* sizeof(pgd_t
), GFP_KERNEL
);
89 for (pgd
= 0; pgd
< n_pgds
; pgd
++) {
90 save_pgd
[pgd
] = *pgd_offset_k(pgd
* PGDIR_SIZE
);
91 vaddress
= (unsigned long)__va(pgd
* PGDIR_SIZE
);
92 set_pgd(pgd_offset_k(pgd
* PGDIR_SIZE
), *pgd_offset_k(vaddress
));
100 void __init
efi_call_phys_epilog(pgd_t
*save_pgd
)
103 * After the lock is released, the original page table is restored.
108 if (!efi_enabled(EFI_OLD_MEMMAP
)) {
109 write_cr3((unsigned long)save_pgd
);
114 nr_pgds
= DIV_ROUND_UP((max_pfn
<< PAGE_SHIFT
) , PGDIR_SIZE
);
116 for (pgd_idx
= 0; pgd_idx
< nr_pgds
; pgd_idx
++)
117 set_pgd(pgd_offset_k(pgd_idx
* PGDIR_SIZE
), save_pgd
[pgd_idx
]);
122 early_code_mapping_set_exec(0);
125 static pgd_t
*efi_pgd
;
128 * We need our own copy of the higher levels of the page tables
129 * because we want to avoid inserting EFI region mappings (EFI_VA_END
130 * to EFI_VA_START) into the standard kernel page tables. Everything
131 * else can be shared, see efi_sync_low_kernel_mappings().
133 int __init
efi_alloc_page_tables(void)
139 if (efi_enabled(EFI_OLD_MEMMAP
))
142 gfp_mask
= GFP_KERNEL
| __GFP_NOTRACK
| __GFP_ZERO
;
143 efi_pgd
= (pgd_t
*)__get_free_page(gfp_mask
);
147 pgd
= efi_pgd
+ pgd_index(EFI_VA_END
);
149 pud
= pud_alloc_one(NULL
, 0);
151 free_page((unsigned long)efi_pgd
);
155 pgd_populate(NULL
, pgd
, pud
);
161 * Add low kernel mappings for passing arguments to EFI functions.
163 void efi_sync_low_kernel_mappings(void)
165 unsigned num_entries
;
166 pgd_t
*pgd_k
, *pgd_efi
;
167 pud_t
*pud_k
, *pud_efi
;
169 if (efi_enabled(EFI_OLD_MEMMAP
))
173 * We can share all PGD entries apart from the one entry that
174 * covers the EFI runtime mapping space.
176 * Make sure the EFI runtime region mappings are guaranteed to
177 * only span a single PGD entry and that the entry also maps
178 * other important kernel regions.
180 BUILD_BUG_ON(pgd_index(EFI_VA_END
) != pgd_index(MODULES_END
));
181 BUILD_BUG_ON((EFI_VA_START
& PGDIR_MASK
) !=
182 (EFI_VA_END
& PGDIR_MASK
));
184 pgd_efi
= efi_pgd
+ pgd_index(PAGE_OFFSET
);
185 pgd_k
= pgd_offset_k(PAGE_OFFSET
);
187 num_entries
= pgd_index(EFI_VA_END
) - pgd_index(PAGE_OFFSET
);
188 memcpy(pgd_efi
, pgd_k
, sizeof(pgd_t
) * num_entries
);
191 * We share all the PUD entries apart from those that map the
192 * EFI regions. Copy around them.
194 BUILD_BUG_ON((EFI_VA_START
& ~PUD_MASK
) != 0);
195 BUILD_BUG_ON((EFI_VA_END
& ~PUD_MASK
) != 0);
197 pgd_efi
= efi_pgd
+ pgd_index(EFI_VA_END
);
198 pud_efi
= pud_offset(pgd_efi
, 0);
200 pgd_k
= pgd_offset_k(EFI_VA_END
);
201 pud_k
= pud_offset(pgd_k
, 0);
203 num_entries
= pud_index(EFI_VA_END
);
204 memcpy(pud_efi
, pud_k
, sizeof(pud_t
) * num_entries
);
206 pud_efi
= pud_offset(pgd_efi
, EFI_VA_START
);
207 pud_k
= pud_offset(pgd_k
, EFI_VA_START
);
209 num_entries
= PTRS_PER_PUD
- pud_index(EFI_VA_START
);
210 memcpy(pud_efi
, pud_k
, sizeof(pud_t
) * num_entries
);
213 int __init
efi_setup_page_tables(unsigned long pa_memmap
, unsigned num_pages
)
215 unsigned long pfn
, text
;
216 efi_memory_desc_t
*md
;
221 if (efi_enabled(EFI_OLD_MEMMAP
))
224 efi_scratch
.efi_pgt
= (pgd_t
*)__pa(efi_pgd
);
228 * It can happen that the physical address of new_memmap lands in memory
229 * which is not mapped in the EFI page table. Therefore we need to go
230 * and ident-map those pages containing the map before calling
231 * phys_efi_set_virtual_address_map().
233 pfn
= pa_memmap
>> PAGE_SHIFT
;
234 if (kernel_map_pages_in_pgd(pgd
, pfn
, pa_memmap
, num_pages
, _PAGE_NX
| _PAGE_RW
)) {
235 pr_err("Error ident-mapping new memmap (0x%lx)!\n", pa_memmap
);
239 efi_scratch
.use_pgd
= true;
242 * When making calls to the firmware everything needs to be 1:1
243 * mapped and addressable with 32-bit pointers. Map the kernel
244 * text and allocate a new stack because we can't rely on the
245 * stack pointer being < 4GB.
247 if (!IS_ENABLED(CONFIG_EFI_MIXED
))
251 * Map all of RAM so that we can access arguments in the 1:1
252 * mapping when making EFI runtime calls.
254 for_each_efi_memory_desc(md
) {
255 if (md
->type
!= EFI_CONVENTIONAL_MEMORY
&&
256 md
->type
!= EFI_LOADER_DATA
&&
257 md
->type
!= EFI_LOADER_CODE
)
260 pfn
= md
->phys_addr
>> PAGE_SHIFT
;
261 npages
= md
->num_pages
;
263 if (kernel_map_pages_in_pgd(pgd
, pfn
, md
->phys_addr
, npages
, _PAGE_RW
)) {
264 pr_err("Failed to map 1:1 memory\n");
269 page
= alloc_page(GFP_KERNEL
|__GFP_DMA32
);
271 panic("Unable to allocate EFI runtime stack < 4GB\n");
273 efi_scratch
.phys_stack
= virt_to_phys(page_address(page
));
274 efi_scratch
.phys_stack
+= PAGE_SIZE
; /* stack grows down */
276 npages
= (_etext
- _text
) >> PAGE_SHIFT
;
278 pfn
= text
>> PAGE_SHIFT
;
280 if (kernel_map_pages_in_pgd(pgd
, pfn
, text
, npages
, _PAGE_RW
)) {
281 pr_err("Failed to map kernel text 1:1\n");
288 static void __init
__map_region(efi_memory_desc_t
*md
, u64 va
)
290 unsigned long flags
= _PAGE_RW
;
292 pgd_t
*pgd
= efi_pgd
;
294 if (!(md
->attribute
& EFI_MEMORY_WB
))
297 pfn
= md
->phys_addr
>> PAGE_SHIFT
;
298 if (kernel_map_pages_in_pgd(pgd
, pfn
, va
, md
->num_pages
, flags
))
299 pr_warn("Error mapping PA 0x%llx -> VA 0x%llx!\n",
303 void __init
efi_map_region(efi_memory_desc_t
*md
)
305 unsigned long size
= md
->num_pages
<< PAGE_SHIFT
;
306 u64 pa
= md
->phys_addr
;
308 if (efi_enabled(EFI_OLD_MEMMAP
))
309 return old_map_region(md
);
312 * Make sure the 1:1 mappings are present as a catch-all for b0rked
313 * firmware which doesn't update all internal pointers after switching
314 * to virtual mode and would otherwise crap on us.
316 __map_region(md
, md
->phys_addr
);
319 * Enforce the 1:1 mapping as the default virtual address when
320 * booting in EFI mixed mode, because even though we may be
321 * running a 64-bit kernel, the firmware may only be 32-bit.
323 if (!efi_is_native () && IS_ENABLED(CONFIG_EFI_MIXED
)) {
324 md
->virt_addr
= md
->phys_addr
;
330 /* Is PA 2M-aligned? */
331 if (!(pa
& (PMD_SIZE
- 1))) {
334 u64 pa_offset
= pa
& (PMD_SIZE
- 1);
335 u64 prev_va
= efi_va
;
337 /* get us the same offset within this 2M page */
338 efi_va
= (efi_va
& PMD_MASK
) + pa_offset
;
340 if (efi_va
> prev_va
)
344 if (efi_va
< EFI_VA_END
) {
345 pr_warn(FW_WARN
"VA address range overflow!\n");
350 __map_region(md
, efi_va
);
351 md
->virt_addr
= efi_va
;
355 * kexec kernel will use efi_map_region_fixed to map efi runtime memory ranges.
356 * md->virt_addr is the original virtual address which had been mapped in kexec
359 void __init
efi_map_region_fixed(efi_memory_desc_t
*md
)
361 __map_region(md
, md
->virt_addr
);
364 void __iomem
*__init
efi_ioremap(unsigned long phys_addr
, unsigned long size
,
365 u32 type
, u64 attribute
)
367 unsigned long last_map_pfn
;
369 if (type
== EFI_MEMORY_MAPPED_IO
)
370 return ioremap(phys_addr
, size
);
372 last_map_pfn
= init_memory_mapping(phys_addr
, phys_addr
+ size
);
373 if ((last_map_pfn
<< PAGE_SHIFT
) < phys_addr
+ size
) {
374 unsigned long top
= last_map_pfn
<< PAGE_SHIFT
;
375 efi_ioremap(top
, size
- (top
- phys_addr
), type
, attribute
);
378 if (!(attribute
& EFI_MEMORY_WB
))
379 efi_memory_uc((u64
)(unsigned long)__va(phys_addr
), size
);
381 return (void __iomem
*)__va(phys_addr
);
384 void __init
parse_efi_setup(u64 phys_addr
, u32 data_len
)
386 efi_setup
= phys_addr
+ sizeof(struct setup_data
);
389 void __init
efi_runtime_update_mappings(void)
392 pgd_t
*pgd
= efi_pgd
;
393 efi_memory_desc_t
*md
;
395 if (efi_enabled(EFI_OLD_MEMMAP
)) {
396 if (__supported_pte_mask
& _PAGE_NX
)
397 runtime_code_page_mkexec();
401 if (!efi_enabled(EFI_NX_PE_DATA
))
404 for_each_efi_memory_desc(md
) {
405 unsigned long pf
= 0;
407 if (!(md
->attribute
& EFI_MEMORY_RUNTIME
))
410 if (!(md
->attribute
& EFI_MEMORY_WB
))
413 if ((md
->attribute
& EFI_MEMORY_XP
) ||
414 (md
->type
== EFI_RUNTIME_SERVICES_DATA
))
417 if (!(md
->attribute
& EFI_MEMORY_RO
) &&
418 (md
->type
!= EFI_RUNTIME_SERVICES_CODE
))
421 /* Update the 1:1 mapping */
422 pfn
= md
->phys_addr
>> PAGE_SHIFT
;
423 if (kernel_map_pages_in_pgd(pgd
, pfn
, md
->phys_addr
, md
->num_pages
, pf
))
424 pr_warn("Error mapping PA 0x%llx -> VA 0x%llx!\n",
425 md
->phys_addr
, md
->virt_addr
);
427 if (kernel_map_pages_in_pgd(pgd
, pfn
, md
->virt_addr
, md
->num_pages
, pf
))
428 pr_warn("Error mapping PA 0x%llx -> VA 0x%llx!\n",
429 md
->phys_addr
, md
->virt_addr
);
433 void __init
efi_dump_pagetable(void)
435 #ifdef CONFIG_EFI_PGT_DUMP
436 ptdump_walk_pgd_level(NULL
, efi_pgd
);
440 #ifdef CONFIG_EFI_MIXED
441 extern efi_status_t
efi64_thunk(u32
, ...);
443 #define runtime_service32(func) \
445 u32 table = (u32)(unsigned long)efi.systab; \
448 rt = (u32 *)(table + offsetof(efi_system_table_32_t, runtime)); \
449 ___f = (u32 *)(*rt + offsetof(efi_runtime_services_32_t, func)); \
454 * Switch to the EFI page tables early so that we can access the 1:1
455 * runtime services mappings which are not mapped in any other page
456 * tables. This function must be called before runtime_service32().
458 * Also, disable interrupts because the IDT points to 64-bit handlers,
459 * which aren't going to function correctly when we switch to 32-bit.
461 #define efi_thunk(f, ...) \
464 unsigned long __flags; \
467 local_irq_save(__flags); \
468 arch_efi_call_virt_setup(); \
470 __func = runtime_service32(f); \
471 __s = efi64_thunk(__func, __VA_ARGS__); \
473 arch_efi_call_virt_teardown(); \
474 local_irq_restore(__flags); \
479 efi_status_t
efi_thunk_set_virtual_address_map(
480 void *phys_set_virtual_address_map
,
481 unsigned long memory_map_size
,
482 unsigned long descriptor_size
,
483 u32 descriptor_version
,
484 efi_memory_desc_t
*virtual_map
)
490 efi_sync_low_kernel_mappings();
491 local_irq_save(flags
);
493 efi_scratch
.prev_cr3
= read_cr3();
494 write_cr3((unsigned long)efi_scratch
.efi_pgt
);
497 func
= (u32
)(unsigned long)phys_set_virtual_address_map
;
498 status
= efi64_thunk(func
, memory_map_size
, descriptor_size
,
499 descriptor_version
, virtual_map
);
501 write_cr3(efi_scratch
.prev_cr3
);
503 local_irq_restore(flags
);
508 static efi_status_t
efi_thunk_get_time(efi_time_t
*tm
, efi_time_cap_t
*tc
)
511 u32 phys_tm
, phys_tc
;
513 spin_lock(&rtc_lock
);
515 phys_tm
= virt_to_phys(tm
);
516 phys_tc
= virt_to_phys(tc
);
518 status
= efi_thunk(get_time
, phys_tm
, phys_tc
);
520 spin_unlock(&rtc_lock
);
525 static efi_status_t
efi_thunk_set_time(efi_time_t
*tm
)
530 spin_lock(&rtc_lock
);
532 phys_tm
= virt_to_phys(tm
);
534 status
= efi_thunk(set_time
, phys_tm
);
536 spin_unlock(&rtc_lock
);
542 efi_thunk_get_wakeup_time(efi_bool_t
*enabled
, efi_bool_t
*pending
,
546 u32 phys_enabled
, phys_pending
, phys_tm
;
548 spin_lock(&rtc_lock
);
550 phys_enabled
= virt_to_phys(enabled
);
551 phys_pending
= virt_to_phys(pending
);
552 phys_tm
= virt_to_phys(tm
);
554 status
= efi_thunk(get_wakeup_time
, phys_enabled
,
555 phys_pending
, phys_tm
);
557 spin_unlock(&rtc_lock
);
563 efi_thunk_set_wakeup_time(efi_bool_t enabled
, efi_time_t
*tm
)
568 spin_lock(&rtc_lock
);
570 phys_tm
= virt_to_phys(tm
);
572 status
= efi_thunk(set_wakeup_time
, enabled
, phys_tm
);
574 spin_unlock(&rtc_lock
);
581 efi_thunk_get_variable(efi_char16_t
*name
, efi_guid_t
*vendor
,
582 u32
*attr
, unsigned long *data_size
, void *data
)
585 u32 phys_name
, phys_vendor
, phys_attr
;
586 u32 phys_data_size
, phys_data
;
588 phys_data_size
= virt_to_phys(data_size
);
589 phys_vendor
= virt_to_phys(vendor
);
590 phys_name
= virt_to_phys(name
);
591 phys_attr
= virt_to_phys(attr
);
592 phys_data
= virt_to_phys(data
);
594 status
= efi_thunk(get_variable
, phys_name
, phys_vendor
,
595 phys_attr
, phys_data_size
, phys_data
);
601 efi_thunk_set_variable(efi_char16_t
*name
, efi_guid_t
*vendor
,
602 u32 attr
, unsigned long data_size
, void *data
)
604 u32 phys_name
, phys_vendor
, phys_data
;
607 phys_name
= virt_to_phys(name
);
608 phys_vendor
= virt_to_phys(vendor
);
609 phys_data
= virt_to_phys(data
);
611 /* If data_size is > sizeof(u32) we've got problems */
612 status
= efi_thunk(set_variable
, phys_name
, phys_vendor
,
613 attr
, data_size
, phys_data
);
619 efi_thunk_get_next_variable(unsigned long *name_size
,
624 u32 phys_name_size
, phys_name
, phys_vendor
;
626 phys_name_size
= virt_to_phys(name_size
);
627 phys_vendor
= virt_to_phys(vendor
);
628 phys_name
= virt_to_phys(name
);
630 status
= efi_thunk(get_next_variable
, phys_name_size
,
631 phys_name
, phys_vendor
);
637 efi_thunk_get_next_high_mono_count(u32
*count
)
642 phys_count
= virt_to_phys(count
);
643 status
= efi_thunk(get_next_high_mono_count
, phys_count
);
649 efi_thunk_reset_system(int reset_type
, efi_status_t status
,
650 unsigned long data_size
, efi_char16_t
*data
)
654 phys_data
= virt_to_phys(data
);
656 efi_thunk(reset_system
, reset_type
, status
, data_size
, phys_data
);
660 efi_thunk_update_capsule(efi_capsule_header_t
**capsules
,
661 unsigned long count
, unsigned long sg_list
)
664 * To properly support this function we would need to repackage
665 * 'capsules' because the firmware doesn't understand 64-bit
668 return EFI_UNSUPPORTED
;
672 efi_thunk_query_variable_info(u32 attr
, u64
*storage_space
,
673 u64
*remaining_space
,
674 u64
*max_variable_size
)
677 u32 phys_storage
, phys_remaining
, phys_max
;
679 if (efi
.runtime_version
< EFI_2_00_SYSTEM_TABLE_REVISION
)
680 return EFI_UNSUPPORTED
;
682 phys_storage
= virt_to_phys(storage_space
);
683 phys_remaining
= virt_to_phys(remaining_space
);
684 phys_max
= virt_to_phys(max_variable_size
);
686 status
= efi_thunk(query_variable_info
, attr
, phys_storage
,
687 phys_remaining
, phys_max
);
693 efi_thunk_query_capsule_caps(efi_capsule_header_t
**capsules
,
694 unsigned long count
, u64
*max_size
,
698 * To properly support this function we would need to repackage
699 * 'capsules' because the firmware doesn't understand 64-bit
702 return EFI_UNSUPPORTED
;
705 void efi_thunk_runtime_setup(void)
707 efi
.get_time
= efi_thunk_get_time
;
708 efi
.set_time
= efi_thunk_set_time
;
709 efi
.get_wakeup_time
= efi_thunk_get_wakeup_time
;
710 efi
.set_wakeup_time
= efi_thunk_set_wakeup_time
;
711 efi
.get_variable
= efi_thunk_get_variable
;
712 efi
.get_next_variable
= efi_thunk_get_next_variable
;
713 efi
.set_variable
= efi_thunk_set_variable
;
714 efi
.get_next_high_mono_count
= efi_thunk_get_next_high_mono_count
;
715 efi
.reset_system
= efi_thunk_reset_system
;
716 efi
.query_variable_info
= efi_thunk_query_variable_info
;
717 efi
.update_capsule
= efi_thunk_update_capsule
;
718 efi
.query_capsule_caps
= efi_thunk_query_capsule_caps
;
720 #endif /* CONFIG_EFI_MIXED */