2 * Common EFI (Extensible Firmware Interface) support functions
3 * Based on Extensible Firmware Interface Specification version 1.0
5 * Copyright (C) 1999 VA Linux Systems
6 * Copyright (C) 1999 Walt Drummond <drummond@valinux.com>
7 * Copyright (C) 1999-2002 Hewlett-Packard Co.
8 * David Mosberger-Tang <davidm@hpl.hp.com>
9 * Stephane Eranian <eranian@hpl.hp.com>
10 * Copyright (C) 2005-2008 Intel Co.
11 * Fenghua Yu <fenghua.yu@intel.com>
12 * Bibo Mao <bibo.mao@intel.com>
13 * Chandramouli Narayanan <mouli@linux.intel.com>
14 * Huang Ying <ying.huang@intel.com>
15 * Copyright (C) 2013 SuSE Labs
16 * Borislav Petkov <bp@suse.de> - runtime services VA mapping
18 * Copied from efi_32.c to eliminate the duplicated code between EFI
19 * 32/64 support code. --ying 2007-10-26
21 * All EFI Runtime Services are not implemented yet as EFI only
22 * supports physical mode addressing on SoftSDV. This is to be fixed
23 * in a future version. --drummond 1999-07-20
25 * Implemented EFI runtime services and virtual mode calls. --davidm
27 * Goutham Rao: <goutham.rao@intel.com>
28 * Skip non-WB memory and ignore empty memory ranges.
31 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
33 #include <linux/kernel.h>
34 #include <linux/init.h>
35 #include <linux/efi.h>
36 #include <linux/efi-bgrt.h>
37 #include <linux/export.h>
38 #include <linux/bootmem.h>
39 #include <linux/slab.h>
40 #include <linux/memblock.h>
41 #include <linux/spinlock.h>
42 #include <linux/uaccess.h>
43 #include <linux/time.h>
45 #include <linux/reboot.h>
46 #include <linux/bcd.h>
48 #include <asm/setup.h>
51 #include <asm/cacheflush.h>
52 #include <asm/tlbflush.h>
53 #include <asm/x86_init.h>
55 #include <asm/uv/uv.h>
59 struct efi_memory_map memmap;
61 static struct efi efi_phys __initdata;
62 static efi_system_table_t efi_systab __initdata;
64 static efi_config_table_type_t arch_tables[] __initdata = {
66 {UV_SYSTEM_TABLE_GUID, "UVsystab", &efi.uv_systab},
68 {NULL_GUID, NULL, NULL},
71 u64 efi_setup; /* efi setup_data physical address */
73 static bool disable_runtime __initdata = false;
74 static int __init setup_noefi(char *arg)
76 disable_runtime = true;
79 early_param("noefi", setup_noefi);
82 EXPORT_SYMBOL(add_efi_memmap);
84 static int __init setup_add_efi_memmap(char *arg)
89 early_param("add_efi_memmap", setup_add_efi_memmap);
91 static efi_status_t virt_efi_get_time(efi_time_t *tm, efi_time_cap_t *tc)
96 spin_lock_irqsave(&rtc_lock, flags);
97 status = efi_call_virt(get_time, tm, tc);
98 spin_unlock_irqrestore(&rtc_lock, flags);
102 static efi_status_t virt_efi_set_time(efi_time_t *tm)
107 spin_lock_irqsave(&rtc_lock, flags);
108 status = efi_call_virt(set_time, tm);
109 spin_unlock_irqrestore(&rtc_lock, flags);
113 static efi_status_t virt_efi_get_wakeup_time(efi_bool_t *enabled,
120 spin_lock_irqsave(&rtc_lock, flags);
121 status = efi_call_virt(get_wakeup_time, enabled, pending, tm);
122 spin_unlock_irqrestore(&rtc_lock, flags);
126 static efi_status_t virt_efi_set_wakeup_time(efi_bool_t enabled, efi_time_t *tm)
131 spin_lock_irqsave(&rtc_lock, flags);
132 status = efi_call_virt(set_wakeup_time, enabled, tm);
133 spin_unlock_irqrestore(&rtc_lock, flags);
137 static efi_status_t virt_efi_get_variable(efi_char16_t *name,
140 unsigned long *data_size,
143 return efi_call_virt(get_variable,
148 static efi_status_t virt_efi_get_next_variable(unsigned long *name_size,
152 return efi_call_virt(get_next_variable,
153 name_size, name, vendor);
156 static efi_status_t virt_efi_set_variable(efi_char16_t *name,
159 unsigned long data_size,
162 return efi_call_virt(set_variable,
167 static efi_status_t virt_efi_query_variable_info(u32 attr,
169 u64 *remaining_space,
170 u64 *max_variable_size)
172 if (efi.runtime_version < EFI_2_00_SYSTEM_TABLE_REVISION)
173 return EFI_UNSUPPORTED;
175 return efi_call_virt(query_variable_info, attr, storage_space,
176 remaining_space, max_variable_size);
179 static efi_status_t virt_efi_get_next_high_mono_count(u32 *count)
181 return efi_call_virt(get_next_high_mono_count, count);
184 static void virt_efi_reset_system(int reset_type,
186 unsigned long data_size,
189 __efi_call_virt(reset_system, reset_type, status,
193 static efi_status_t virt_efi_update_capsule(efi_capsule_header_t **capsules,
195 unsigned long sg_list)
197 if (efi.runtime_version < EFI_2_00_SYSTEM_TABLE_REVISION)
198 return EFI_UNSUPPORTED;
200 return efi_call_virt(update_capsule, capsules, count, sg_list);
203 static efi_status_t virt_efi_query_capsule_caps(efi_capsule_header_t **capsules,
208 if (efi.runtime_version < EFI_2_00_SYSTEM_TABLE_REVISION)
209 return EFI_UNSUPPORTED;
211 return efi_call_virt(query_capsule_caps, capsules, count, max_size,
215 static efi_status_t __init phys_efi_set_virtual_address_map(
216 unsigned long memory_map_size,
217 unsigned long descriptor_size,
218 u32 descriptor_version,
219 efi_memory_desc_t *virtual_map)
223 efi_call_phys_prelog();
224 status = efi_call_phys(efi_phys.set_virtual_address_map,
225 memory_map_size, descriptor_size,
226 descriptor_version, virtual_map);
227 efi_call_phys_epilog();
231 int efi_set_rtc_mmss(const struct timespec *now)
233 unsigned long nowtime = now->tv_sec;
239 status = efi.get_time(&eft, &cap);
240 if (status != EFI_SUCCESS) {
241 pr_err("Oops: efitime: can't read time!\n");
245 rtc_time_to_tm(nowtime, &tm);
246 if (!rtc_valid_tm(&tm)) {
247 eft.year = tm.tm_year + 1900;
248 eft.month = tm.tm_mon + 1;
249 eft.day = tm.tm_mday;
250 eft.minute = tm.tm_min;
251 eft.second = tm.tm_sec;
254 pr_err("%s: Invalid EFI RTC value: write of %lx to EFI RTC failed\n",
259 status = efi.set_time(&eft);
260 if (status != EFI_SUCCESS) {
261 pr_err("Oops: efitime: can't write time!\n");
267 void efi_get_time(struct timespec *now)
273 status = efi.get_time(&eft, &cap);
274 if (status != EFI_SUCCESS)
275 pr_err("Oops: efitime: can't read time!\n");
277 now->tv_sec = mktime(eft.year, eft.month, eft.day, eft.hour,
278 eft.minute, eft.second);
283 * Tell the kernel about the EFI memory map. This might include
284 * more than the max 128 entries that can fit in the e820 legacy
285 * (zeropage) memory map.
288 static void __init do_add_efi_memmap(void)
292 for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) {
293 efi_memory_desc_t *md = p;
294 unsigned long long start = md->phys_addr;
295 unsigned long long size = md->num_pages << EFI_PAGE_SHIFT;
299 case EFI_LOADER_CODE:
300 case EFI_LOADER_DATA:
301 case EFI_BOOT_SERVICES_CODE:
302 case EFI_BOOT_SERVICES_DATA:
303 case EFI_CONVENTIONAL_MEMORY:
304 if (md->attribute & EFI_MEMORY_WB)
305 e820_type = E820_RAM;
307 e820_type = E820_RESERVED;
309 case EFI_ACPI_RECLAIM_MEMORY:
310 e820_type = E820_ACPI;
312 case EFI_ACPI_MEMORY_NVS:
313 e820_type = E820_NVS;
315 case EFI_UNUSABLE_MEMORY:
316 e820_type = E820_UNUSABLE;
320 * EFI_RESERVED_TYPE EFI_RUNTIME_SERVICES_CODE
321 * EFI_RUNTIME_SERVICES_DATA EFI_MEMORY_MAPPED_IO
322 * EFI_MEMORY_MAPPED_IO_PORT_SPACE EFI_PAL_CODE
324 e820_type = E820_RESERVED;
327 e820_add_region(start, size, e820_type);
329 sanitize_e820_map(e820.map, ARRAY_SIZE(e820.map), &e820.nr_map);
332 int __init efi_memblock_x86_reserve_range(void)
334 struct efi_info *e = &boot_params.efi_info;
338 /* Can't handle data above 4GB at this time */
339 if (e->efi_memmap_hi) {
340 pr_err("Memory map is above 4GB, disabling EFI.\n");
343 pmap = e->efi_memmap;
345 pmap = (e->efi_memmap | ((__u64)e->efi_memmap_hi << 32));
347 memmap.phys_map = (void *)pmap;
348 memmap.nr_map = e->efi_memmap_size /
350 memmap.desc_size = e->efi_memdesc_size;
351 memmap.desc_version = e->efi_memdesc_version;
353 memblock_reserve(pmap, memmap.nr_map * memmap.desc_size);
355 efi.memmap = &memmap;
360 static void __init print_efi_memmap(void)
363 efi_memory_desc_t *md;
367 for (p = memmap.map, i = 0;
369 p += memmap.desc_size, i++) {
371 pr_info("mem%02u: type=%u, attr=0x%llx, range=[0x%016llx-0x%016llx) (%lluMB)\n",
372 i, md->type, md->attribute, md->phys_addr,
373 md->phys_addr + (md->num_pages << EFI_PAGE_SHIFT),
374 (md->num_pages >> (20 - EFI_PAGE_SHIFT)));
376 #endif /* EFI_DEBUG */
379 void __init efi_unmap_memmap(void)
381 clear_bit(EFI_MEMMAP, &efi.flags);
383 early_iounmap(memmap.map, memmap.nr_map * memmap.desc_size);
388 static int __init efi_systab_init(void *phys)
390 if (efi_enabled(EFI_64BIT)) {
391 efi_system_table_64_t *systab64;
392 struct efi_setup_data *data = NULL;
396 data = early_memremap(efi_setup, sizeof(*data));
400 systab64 = early_ioremap((unsigned long)phys,
402 if (systab64 == NULL) {
403 pr_err("Couldn't map the system table!\n");
405 early_iounmap(data, sizeof(*data));
409 efi_systab.hdr = systab64->hdr;
410 efi_systab.fw_vendor = data ? (unsigned long)data->fw_vendor :
412 tmp |= data ? data->fw_vendor : systab64->fw_vendor;
413 efi_systab.fw_revision = systab64->fw_revision;
414 efi_systab.con_in_handle = systab64->con_in_handle;
415 tmp |= systab64->con_in_handle;
416 efi_systab.con_in = systab64->con_in;
417 tmp |= systab64->con_in;
418 efi_systab.con_out_handle = systab64->con_out_handle;
419 tmp |= systab64->con_out_handle;
420 efi_systab.con_out = systab64->con_out;
421 tmp |= systab64->con_out;
422 efi_systab.stderr_handle = systab64->stderr_handle;
423 tmp |= systab64->stderr_handle;
424 efi_systab.stderr = systab64->stderr;
425 tmp |= systab64->stderr;
426 efi_systab.runtime = data ?
427 (void *)(unsigned long)data->runtime :
428 (void *)(unsigned long)systab64->runtime;
429 tmp |= data ? data->runtime : systab64->runtime;
430 efi_systab.boottime = (void *)(unsigned long)systab64->boottime;
431 tmp |= systab64->boottime;
432 efi_systab.nr_tables = systab64->nr_tables;
433 efi_systab.tables = data ? (unsigned long)data->tables :
435 tmp |= data ? data->tables : systab64->tables;
437 early_iounmap(systab64, sizeof(*systab64));
439 early_iounmap(data, sizeof(*data));
442 pr_err("EFI data located above 4GB, disabling EFI.\n");
447 efi_system_table_32_t *systab32;
449 systab32 = early_ioremap((unsigned long)phys,
451 if (systab32 == NULL) {
452 pr_err("Couldn't map the system table!\n");
456 efi_systab.hdr = systab32->hdr;
457 efi_systab.fw_vendor = systab32->fw_vendor;
458 efi_systab.fw_revision = systab32->fw_revision;
459 efi_systab.con_in_handle = systab32->con_in_handle;
460 efi_systab.con_in = systab32->con_in;
461 efi_systab.con_out_handle = systab32->con_out_handle;
462 efi_systab.con_out = systab32->con_out;
463 efi_systab.stderr_handle = systab32->stderr_handle;
464 efi_systab.stderr = systab32->stderr;
465 efi_systab.runtime = (void *)(unsigned long)systab32->runtime;
466 efi_systab.boottime = (void *)(unsigned long)systab32->boottime;
467 efi_systab.nr_tables = systab32->nr_tables;
468 efi_systab.tables = systab32->tables;
470 early_iounmap(systab32, sizeof(*systab32));
473 efi.systab = &efi_systab;
476 * Verify the EFI Table
478 if (efi.systab->hdr.signature != EFI_SYSTEM_TABLE_SIGNATURE) {
479 pr_err("System table signature incorrect!\n");
482 if ((efi.systab->hdr.revision >> 16) == 0)
483 pr_err("Warning: System table version %d.%02d, expected 1.00 or greater!\n",
484 efi.systab->hdr.revision >> 16,
485 efi.systab->hdr.revision & 0xffff);
487 set_bit(EFI_SYSTEM_TABLES, &efi.flags);
492 static int __init efi_runtime_init32(void)
494 efi_runtime_services_32_t *runtime;
496 runtime = early_ioremap((unsigned long)efi.systab->runtime,
497 sizeof(efi_runtime_services_32_t));
499 pr_err("Could not map the runtime service table!\n");
504 * We will only need *early* access to the following two
505 * EFI runtime services before set_virtual_address_map
508 efi_phys.set_virtual_address_map =
509 (efi_set_virtual_address_map_t *)
510 (unsigned long)runtime->set_virtual_address_map;
511 early_iounmap(runtime, sizeof(efi_runtime_services_32_t));
516 static int __init efi_runtime_init64(void)
518 efi_runtime_services_64_t *runtime;
520 runtime = early_ioremap((unsigned long)efi.systab->runtime,
521 sizeof(efi_runtime_services_64_t));
523 pr_err("Could not map the runtime service table!\n");
528 * We will only need *early* access to the following two
529 * EFI runtime services before set_virtual_address_map
532 efi_phys.set_virtual_address_map =
533 (efi_set_virtual_address_map_t *)
534 (unsigned long)runtime->set_virtual_address_map;
535 early_iounmap(runtime, sizeof(efi_runtime_services_64_t));
540 static int __init efi_runtime_init(void)
545 * Check out the runtime services table. We need to map
546 * the runtime services table so that we can grab the physical
547 * address of several of the EFI runtime functions, needed to
548 * set the firmware into virtual mode.
550 if (efi_enabled(EFI_64BIT))
551 rv = efi_runtime_init64();
553 rv = efi_runtime_init32();
558 set_bit(EFI_RUNTIME_SERVICES, &efi.flags);
563 static int __init efi_memmap_init(void)
565 /* Map the EFI memory map */
566 memmap.map = early_ioremap((unsigned long)memmap.phys_map,
567 memmap.nr_map * memmap.desc_size);
568 if (memmap.map == NULL) {
569 pr_err("Could not map the memory map!\n");
572 memmap.map_end = memmap.map + (memmap.nr_map * memmap.desc_size);
577 set_bit(EFI_MEMMAP, &efi.flags);
582 void __init efi_init(void)
585 char vendor[100] = "unknown";
590 if (boot_params.efi_info.efi_systab_hi ||
591 boot_params.efi_info.efi_memmap_hi) {
592 pr_info("Table located above 4GB, disabling EFI.\n");
595 efi_phys.systab = (efi_system_table_t *)boot_params.efi_info.efi_systab;
597 efi_phys.systab = (efi_system_table_t *)
598 (boot_params.efi_info.efi_systab |
599 ((__u64)boot_params.efi_info.efi_systab_hi<<32));
602 if (efi_systab_init(efi_phys.systab))
605 set_bit(EFI_SYSTEM_TABLES, &efi.flags);
607 efi.config_table = (unsigned long)efi.systab->tables;
608 efi.fw_vendor = (unsigned long)efi.systab->fw_vendor;
609 efi.runtime = (unsigned long)efi.systab->runtime;
612 * Show what we know for posterity
614 c16 = tmp = early_ioremap(efi.systab->fw_vendor, 2);
616 for (i = 0; i < sizeof(vendor) - 1 && *c16; ++i)
620 pr_err("Could not map the firmware vendor!\n");
621 early_iounmap(tmp, 2);
623 pr_info("EFI v%u.%.02u by %s\n",
624 efi.systab->hdr.revision >> 16,
625 efi.systab->hdr.revision & 0xffff, vendor);
627 if (efi_reuse_config(efi.systab->tables, efi.systab->nr_tables))
630 if (efi_config_init(arch_tables))
634 * Note: We currently don't support runtime services on an EFI
635 * that doesn't match the kernel 32/64-bit mode.
638 if (!efi_runtime_supported())
639 pr_info("No EFI runtime due to 32/64-bit mismatch with kernel\n");
641 if (disable_runtime || efi_runtime_init())
644 if (efi_memmap_init())
647 set_bit(EFI_MEMMAP, &efi.flags);
652 void __init efi_late_init(void)
657 void __init efi_set_executable(efi_memory_desc_t *md, bool executable)
661 addr = md->virt_addr;
662 npages = md->num_pages;
664 memrange_efi_to_native(&addr, &npages);
667 set_memory_x(addr, npages);
669 set_memory_nx(addr, npages);
672 void __init runtime_code_page_mkexec(void)
674 efi_memory_desc_t *md;
677 /* Make EFI runtime service code area executable */
678 for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) {
681 if (md->type != EFI_RUNTIME_SERVICES_CODE)
684 efi_set_executable(md, true);
688 void efi_memory_uc(u64 addr, unsigned long size)
690 unsigned long page_shift = 1UL << EFI_PAGE_SHIFT;
693 npages = round_up(size, page_shift) / page_shift;
694 memrange_efi_to_native(&addr, &npages);
695 set_memory_uc(addr, npages);
698 void __init old_map_region(efi_memory_desc_t *md)
700 u64 start_pfn, end_pfn, end;
704 start_pfn = PFN_DOWN(md->phys_addr);
705 size = md->num_pages << PAGE_SHIFT;
706 end = md->phys_addr + size;
707 end_pfn = PFN_UP(end);
709 if (pfn_range_is_mapped(start_pfn, end_pfn)) {
710 va = __va(md->phys_addr);
712 if (!(md->attribute & EFI_MEMORY_WB))
713 efi_memory_uc((u64)(unsigned long)va, size);
715 va = efi_ioremap(md->phys_addr, size,
716 md->type, md->attribute);
718 md->virt_addr = (u64) (unsigned long) va;
720 pr_err("ioremap of 0x%llX failed!\n",
721 (unsigned long long)md->phys_addr);
724 static void native_runtime_setup(void)
726 efi.get_time = virt_efi_get_time;
727 efi.set_time = virt_efi_set_time;
728 efi.get_wakeup_time = virt_efi_get_wakeup_time;
729 efi.set_wakeup_time = virt_efi_set_wakeup_time;
730 efi.get_variable = virt_efi_get_variable;
731 efi.get_next_variable = virt_efi_get_next_variable;
732 efi.set_variable = virt_efi_set_variable;
733 efi.get_next_high_mono_count = virt_efi_get_next_high_mono_count;
734 efi.reset_system = virt_efi_reset_system;
735 efi.query_variable_info = virt_efi_query_variable_info;
736 efi.update_capsule = virt_efi_update_capsule;
737 efi.query_capsule_caps = virt_efi_query_capsule_caps;
740 /* Merge contiguous regions of the same type and attribute */
741 static void __init efi_merge_regions(void)
744 efi_memory_desc_t *md, *prev_md = NULL;
746 for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) {
755 if (prev_md->type != md->type ||
756 prev_md->attribute != md->attribute) {
761 prev_size = prev_md->num_pages << EFI_PAGE_SHIFT;
763 if (md->phys_addr == (prev_md->phys_addr + prev_size)) {
764 prev_md->num_pages += md->num_pages;
765 md->type = EFI_RESERVED_TYPE;
773 static void __init get_systab_virt_addr(efi_memory_desc_t *md)
778 size = md->num_pages << EFI_PAGE_SHIFT;
779 end = md->phys_addr + size;
780 systab = (u64)(unsigned long)efi_phys.systab;
781 if (md->phys_addr <= systab && systab < end) {
782 systab += md->virt_addr - md->phys_addr;
783 efi.systab = (efi_system_table_t *)(unsigned long)systab;
787 static void __init save_runtime_map(void)
790 efi_memory_desc_t *md;
791 void *tmp, *p, *q = NULL;
794 if (efi_enabled(EFI_OLD_MEMMAP))
797 for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) {
800 if (!(md->attribute & EFI_MEMORY_RUNTIME) ||
801 (md->type == EFI_BOOT_SERVICES_CODE) ||
802 (md->type == EFI_BOOT_SERVICES_DATA))
804 tmp = krealloc(q, (count + 1) * memmap.desc_size, GFP_KERNEL);
809 memcpy(q + count * memmap.desc_size, md, memmap.desc_size);
813 efi_runtime_map_setup(q, count, memmap.desc_size);
818 pr_err("Error saving runtime map, efi runtime on kexec non-functional!!\n");
822 static void *realloc_pages(void *old_memmap, int old_shift)
826 ret = (void *)__get_free_pages(GFP_KERNEL, old_shift + 1);
831 * A first-time allocation doesn't have anything to copy.
836 memcpy(ret, old_memmap, PAGE_SIZE << old_shift);
839 free_pages((unsigned long)old_memmap, old_shift);
844 * Map the efi memory ranges of the runtime services and update new_mmap with
847 static void * __init efi_map_regions(int *count, int *pg_shift)
849 void *p, *new_memmap = NULL;
850 unsigned long left = 0;
851 efi_memory_desc_t *md;
853 for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) {
855 if (!(md->attribute & EFI_MEMORY_RUNTIME)) {
857 if (md->type != EFI_BOOT_SERVICES_CODE &&
858 md->type != EFI_BOOT_SERVICES_DATA)
864 get_systab_virt_addr(md);
866 if (left < memmap.desc_size) {
867 new_memmap = realloc_pages(new_memmap, *pg_shift);
871 left += PAGE_SIZE << *pg_shift;
875 memcpy(new_memmap + (*count * memmap.desc_size), md,
878 left -= memmap.desc_size;
885 static void __init kexec_enter_virtual_mode(void)
888 efi_memory_desc_t *md;
894 * We don't do virtual mode, since we don't do runtime services, on
897 if (!efi_is_native()) {
903 * Map efi regions which were passed via setup_data. The virt_addr is a
904 * fixed addr which was used in first kernel of a kexec boot.
906 for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) {
908 efi_map_region_fixed(md); /* FIXME: add error handling */
909 get_systab_virt_addr(md);
916 efi_sync_low_kernel_mappings();
919 * Now that EFI is in virtual mode, update the function
920 * pointers in the runtime service table to the new virtual addresses.
922 * Call EFI services through wrapper functions.
924 efi.runtime_version = efi_systab.hdr.revision;
926 native_runtime_setup();
928 efi.set_virtual_address_map = NULL;
930 if (efi_enabled(EFI_OLD_MEMMAP) && (__supported_pte_mask & _PAGE_NX))
931 runtime_code_page_mkexec();
933 /* clean DUMMY object */
934 efi_delete_dummy_variable();
939 * This function will switch the EFI runtime services to virtual mode.
940 * Essentially, we look through the EFI memmap and map every region that
941 * has the runtime attribute bit set in its memory descriptor into the
942 * ->trampoline_pgd page table using a top-down VA allocation scheme.
944 * The old method which used to update that memory descriptor with the
945 * virtual address obtained from ioremap() is still supported when the
946 * kernel is booted with efi=old_map on its command line. Same old
947 * method enabled the runtime services to be called without having to
948 * thunk back into physical mode for every invocation.
950 * The new method does a pagetable switch in a preemption-safe manner
951 * so that we're in a different address space when calling a runtime
952 * function. For function arguments passing we do copy the PGDs of the
953 * kernel page table into ->trampoline_pgd prior to each call.
955 * Specially for kexec boot, efi runtime maps in previous kernel should
956 * be passed in via setup_data. In that case runtime ranges will be mapped
957 * to the same virtual addresses as the first kernel, see
958 * kexec_enter_virtual_mode().
960 static void __init __efi_enter_virtual_mode(void)
962 int count = 0, pg_shift = 0;
963 void *new_memmap = NULL;
969 new_memmap = efi_map_regions(&count, &pg_shift);
971 pr_err("Error reallocating memory, EFI runtime non-functional!\n");
979 if (efi_setup_page_tables(__pa(new_memmap), 1 << pg_shift))
982 efi_sync_low_kernel_mappings();
983 efi_dump_pagetable();
985 if (efi_is_native()) {
986 status = phys_efi_set_virtual_address_map(
987 memmap.desc_size * count,
990 (efi_memory_desc_t *)__pa(new_memmap));
992 status = efi_thunk_set_virtual_address_map(
993 efi_phys.set_virtual_address_map,
994 memmap.desc_size * count,
997 (efi_memory_desc_t *)__pa(new_memmap));
1000 if (status != EFI_SUCCESS) {
1001 pr_alert("Unable to switch EFI into virtual mode (status=%lx)!\n",
1003 panic("EFI call to SetVirtualAddressMap() failed!");
1007 * Now that EFI is in virtual mode, update the function
1008 * pointers in the runtime service table to the new virtual addresses.
1010 * Call EFI services through wrapper functions.
1012 efi.runtime_version = efi_systab.hdr.revision;
1014 if (efi_is_native())
1015 native_runtime_setup();
1017 efi_thunk_runtime_setup();
1019 efi.set_virtual_address_map = NULL;
1021 efi_runtime_mkexec();
1024 * We mapped the descriptor array into the EFI pagetable above but we're
1025 * not unmapping it here. Here's why:
1027 * We're copying select PGDs from the kernel page table to the EFI page
1028 * table and when we do so and make changes to those PGDs like unmapping
1029 * stuff from them, those changes appear in the kernel page table and we
1032 * From setup_real_mode():
1035 * trampoline_pgd[0] = init_level4_pgt[pgd_index(__PAGE_OFFSET)].pgd;
1037 * In this particular case, our allocation is in PGD 0 of the EFI page
1038 * table but we've copied that PGD from PGD[272] of the EFI page table:
1040 * pgd_index(__PAGE_OFFSET = 0xffff880000000000) = 272
1042 * where the direct memory mapping in kernel space is.
1044 * new_memmap's VA comes from that direct mapping and thus clearing it,
1045 * it would get cleared in the kernel page table too.
1047 * efi_cleanup_page_tables(__pa(new_memmap), 1 << pg_shift);
1049 free_pages((unsigned long)new_memmap, pg_shift);
1051 /* clean DUMMY object */
1052 efi_delete_dummy_variable();
1055 void __init efi_enter_virtual_mode(void)
1058 kexec_enter_virtual_mode();
1060 __efi_enter_virtual_mode();
1064 * Convenience functions to obtain memory types and attributes
1066 u32 efi_mem_type(unsigned long phys_addr)
1068 efi_memory_desc_t *md;
1071 if (!efi_enabled(EFI_MEMMAP))
1074 for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) {
1076 if ((md->phys_addr <= phys_addr) &&
1077 (phys_addr < (md->phys_addr +
1078 (md->num_pages << EFI_PAGE_SHIFT))))
1084 u64 efi_mem_attributes(unsigned long phys_addr)
1086 efi_memory_desc_t *md;
1089 for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) {
1091 if ((md->phys_addr <= phys_addr) &&
1092 (phys_addr < (md->phys_addr +
1093 (md->num_pages << EFI_PAGE_SHIFT))))
1094 return md->attribute;
1099 static int __init parse_efi_cmdline(char *str)
1104 if (!strncmp(str, "old_map", 7))
1105 set_bit(EFI_OLD_MEMMAP, &efi.flags);
1109 early_param("efi", parse_efi_cmdline);