1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
32
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>
44#include <linux/io.h>
45#include <linux/reboot.h>
46#include <linux/bcd.h>
47
48#include <asm/setup.h>
49#include <asm/efi.h>
50#include <asm/time.h>
51#include <asm/cacheflush.h>
52#include <asm/tlbflush.h>
53#include <asm/x86_init.h>
54#include <asm/rtc.h>
55#include <asm/uv/uv.h>
56
57#define EFI_DEBUG
58
59struct efi_memory_map memmap;
60
61static struct efi efi_phys __initdata;
62static efi_system_table_t efi_systab __initdata;
63
64static efi_config_table_type_t arch_tables[] __initdata = {
65#ifdef CONFIG_X86_UV
66 {UV_SYSTEM_TABLE_GUID, "UVsystab", &efi.uv_systab},
67#endif
68 {NULL_GUID, NULL, NULL},
69};
70
71u64 efi_setup;
72
73static int add_efi_memmap __initdata;
74static int __init setup_add_efi_memmap(char *arg)
75{
76 add_efi_memmap = 1;
77 return 0;
78}
79early_param("add_efi_memmap", setup_add_efi_memmap);
80
81static efi_status_t __init phys_efi_set_virtual_address_map(
82 unsigned long memory_map_size,
83 unsigned long descriptor_size,
84 u32 descriptor_version,
85 efi_memory_desc_t *virtual_map)
86{
87 efi_status_t status;
88 unsigned long flags;
89 pgd_t *save_pgd;
90
91 save_pgd = efi_call_phys_prolog();
92
93
94 local_irq_save(flags);
95 status = efi_call_phys(efi_phys.set_virtual_address_map,
96 memory_map_size, descriptor_size,
97 descriptor_version, virtual_map);
98 local_irq_restore(flags);
99
100 efi_call_phys_epilog(save_pgd);
101
102 return status;
103}
104
105void efi_get_time(struct timespec *now)
106{
107 efi_status_t status;
108 efi_time_t eft;
109 efi_time_cap_t cap;
110
111 status = efi.get_time(&eft, &cap);
112 if (status != EFI_SUCCESS)
113 pr_err("Oops: efitime: can't read time!\n");
114
115 now->tv_sec = mktime(eft.year, eft.month, eft.day, eft.hour,
116 eft.minute, eft.second);
117 now->tv_nsec = 0;
118}
119
120void __init efi_find_mirror(void)
121{
122 void *p;
123 u64 mirror_size = 0, total_size = 0;
124
125 for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) {
126 efi_memory_desc_t *md = p;
127 unsigned long long start = md->phys_addr;
128 unsigned long long size = md->num_pages << EFI_PAGE_SHIFT;
129
130 total_size += size;
131 if (md->attribute & EFI_MEMORY_MORE_RELIABLE) {
132 memblock_mark_mirror(start, size);
133 mirror_size += size;
134 }
135 }
136 if (mirror_size)
137 pr_info("Memory: %lldM/%lldM mirrored memory\n",
138 mirror_size>>20, total_size>>20);
139}
140
141
142
143
144
145
146
147static void __init do_add_efi_memmap(void)
148{
149 void *p;
150
151 for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) {
152 efi_memory_desc_t *md = p;
153 unsigned long long start = md->phys_addr;
154 unsigned long long size = md->num_pages << EFI_PAGE_SHIFT;
155 int e820_type;
156
157 switch (md->type) {
158 case EFI_LOADER_CODE:
159 case EFI_LOADER_DATA:
160 case EFI_BOOT_SERVICES_CODE:
161 case EFI_BOOT_SERVICES_DATA:
162 case EFI_CONVENTIONAL_MEMORY:
163 if (md->attribute & EFI_MEMORY_WB)
164 e820_type = E820_RAM;
165 else
166 e820_type = E820_RESERVED;
167 break;
168 case EFI_ACPI_RECLAIM_MEMORY:
169 e820_type = E820_ACPI;
170 break;
171 case EFI_ACPI_MEMORY_NVS:
172 e820_type = E820_NVS;
173 break;
174 case EFI_UNUSABLE_MEMORY:
175 e820_type = E820_UNUSABLE;
176 break;
177 case EFI_PERSISTENT_MEMORY:
178 e820_type = E820_PMEM;
179 break;
180 default:
181
182
183
184
185
186 e820_type = E820_RESERVED;
187 break;
188 }
189 e820_add_region(start, size, e820_type);
190 }
191 sanitize_e820_map(e820.map, ARRAY_SIZE(e820.map), &e820.nr_map);
192}
193
194int __init efi_memblock_x86_reserve_range(void)
195{
196 struct efi_info *e = &boot_params.efi_info;
197 phys_addr_t pmap;
198
199 if (efi_enabled(EFI_PARAVIRT))
200 return 0;
201
202#ifdef CONFIG_X86_32
203
204 if (e->efi_memmap_hi) {
205 pr_err("Memory map is above 4GB, disabling EFI.\n");
206 return -EINVAL;
207 }
208 pmap = e->efi_memmap;
209#else
210 pmap = (e->efi_memmap | ((__u64)e->efi_memmap_hi << 32));
211#endif
212 memmap.phys_map = pmap;
213 memmap.nr_map = e->efi_memmap_size /
214 e->efi_memdesc_size;
215 memmap.desc_size = e->efi_memdesc_size;
216 memmap.desc_version = e->efi_memdesc_version;
217
218 memblock_reserve(pmap, memmap.nr_map * memmap.desc_size);
219
220 efi.memmap = &memmap;
221
222 return 0;
223}
224
225void __init efi_print_memmap(void)
226{
227#ifdef EFI_DEBUG
228 efi_memory_desc_t *md;
229 void *p;
230 int i;
231
232 for (p = memmap.map, i = 0;
233 p < memmap.map_end;
234 p += memmap.desc_size, i++) {
235 char buf[64];
236
237 md = p;
238 pr_info("mem%02u: %s range=[0x%016llx-0x%016llx] (%lluMB)\n",
239 i, efi_md_typeattr_format(buf, sizeof(buf), md),
240 md->phys_addr,
241 md->phys_addr + (md->num_pages << EFI_PAGE_SHIFT) - 1,
242 (md->num_pages >> (20 - EFI_PAGE_SHIFT)));
243 }
244#endif
245}
246
247void __init efi_unmap_memmap(void)
248{
249 clear_bit(EFI_MEMMAP, &efi.flags);
250 if (memmap.map) {
251 early_memunmap(memmap.map, memmap.nr_map * memmap.desc_size);
252 memmap.map = NULL;
253 }
254}
255
256static int __init efi_systab_init(void *phys)
257{
258 if (efi_enabled(EFI_64BIT)) {
259 efi_system_table_64_t *systab64;
260 struct efi_setup_data *data = NULL;
261 u64 tmp = 0;
262
263 if (efi_setup) {
264 data = early_memremap(efi_setup, sizeof(*data));
265 if (!data)
266 return -ENOMEM;
267 }
268 systab64 = early_memremap((unsigned long)phys,
269 sizeof(*systab64));
270 if (systab64 == NULL) {
271 pr_err("Couldn't map the system table!\n");
272 if (data)
273 early_memunmap(data, sizeof(*data));
274 return -ENOMEM;
275 }
276
277 efi_systab.hdr = systab64->hdr;
278 efi_systab.fw_vendor = data ? (unsigned long)data->fw_vendor :
279 systab64->fw_vendor;
280 tmp |= data ? data->fw_vendor : systab64->fw_vendor;
281 efi_systab.fw_revision = systab64->fw_revision;
282 efi_systab.con_in_handle = systab64->con_in_handle;
283 tmp |= systab64->con_in_handle;
284 efi_systab.con_in = systab64->con_in;
285 tmp |= systab64->con_in;
286 efi_systab.con_out_handle = systab64->con_out_handle;
287 tmp |= systab64->con_out_handle;
288 efi_systab.con_out = systab64->con_out;
289 tmp |= systab64->con_out;
290 efi_systab.stderr_handle = systab64->stderr_handle;
291 tmp |= systab64->stderr_handle;
292 efi_systab.stderr = systab64->stderr;
293 tmp |= systab64->stderr;
294 efi_systab.runtime = data ?
295 (void *)(unsigned long)data->runtime :
296 (void *)(unsigned long)systab64->runtime;
297 tmp |= data ? data->runtime : systab64->runtime;
298 efi_systab.boottime = (void *)(unsigned long)systab64->boottime;
299 tmp |= systab64->boottime;
300 efi_systab.nr_tables = systab64->nr_tables;
301 efi_systab.tables = data ? (unsigned long)data->tables :
302 systab64->tables;
303 tmp |= data ? data->tables : systab64->tables;
304
305 early_memunmap(systab64, sizeof(*systab64));
306 if (data)
307 early_memunmap(data, sizeof(*data));
308#ifdef CONFIG_X86_32
309 if (tmp >> 32) {
310 pr_err("EFI data located above 4GB, disabling EFI.\n");
311 return -EINVAL;
312 }
313#endif
314 } else {
315 efi_system_table_32_t *systab32;
316
317 systab32 = early_memremap((unsigned long)phys,
318 sizeof(*systab32));
319 if (systab32 == NULL) {
320 pr_err("Couldn't map the system table!\n");
321 return -ENOMEM;
322 }
323
324 efi_systab.hdr = systab32->hdr;
325 efi_systab.fw_vendor = systab32->fw_vendor;
326 efi_systab.fw_revision = systab32->fw_revision;
327 efi_systab.con_in_handle = systab32->con_in_handle;
328 efi_systab.con_in = systab32->con_in;
329 efi_systab.con_out_handle = systab32->con_out_handle;
330 efi_systab.con_out = systab32->con_out;
331 efi_systab.stderr_handle = systab32->stderr_handle;
332 efi_systab.stderr = systab32->stderr;
333 efi_systab.runtime = (void *)(unsigned long)systab32->runtime;
334 efi_systab.boottime = (void *)(unsigned long)systab32->boottime;
335 efi_systab.nr_tables = systab32->nr_tables;
336 efi_systab.tables = systab32->tables;
337
338 early_memunmap(systab32, sizeof(*systab32));
339 }
340
341 efi.systab = &efi_systab;
342
343
344
345
346 if (efi.systab->hdr.signature != EFI_SYSTEM_TABLE_SIGNATURE) {
347 pr_err("System table signature incorrect!\n");
348 return -EINVAL;
349 }
350 if ((efi.systab->hdr.revision >> 16) == 0)
351 pr_err("Warning: System table version %d.%02d, expected 1.00 or greater!\n",
352 efi.systab->hdr.revision >> 16,
353 efi.systab->hdr.revision & 0xffff);
354
355 set_bit(EFI_SYSTEM_TABLES, &efi.flags);
356
357 return 0;
358}
359
360static int __init efi_runtime_init32(void)
361{
362 efi_runtime_services_32_t *runtime;
363
364 runtime = early_memremap((unsigned long)efi.systab->runtime,
365 sizeof(efi_runtime_services_32_t));
366 if (!runtime) {
367 pr_err("Could not map the runtime service table!\n");
368 return -ENOMEM;
369 }
370
371
372
373
374
375
376 efi_phys.set_virtual_address_map =
377 (efi_set_virtual_address_map_t *)
378 (unsigned long)runtime->set_virtual_address_map;
379 early_memunmap(runtime, sizeof(efi_runtime_services_32_t));
380
381 return 0;
382}
383
384static int __init efi_runtime_init64(void)
385{
386 efi_runtime_services_64_t *runtime;
387
388 runtime = early_memremap((unsigned long)efi.systab->runtime,
389 sizeof(efi_runtime_services_64_t));
390 if (!runtime) {
391 pr_err("Could not map the runtime service table!\n");
392 return -ENOMEM;
393 }
394
395
396
397
398
399
400 efi_phys.set_virtual_address_map =
401 (efi_set_virtual_address_map_t *)
402 (unsigned long)runtime->set_virtual_address_map;
403 early_memunmap(runtime, sizeof(efi_runtime_services_64_t));
404
405 return 0;
406}
407
408static int __init efi_runtime_init(void)
409{
410 int rv;
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426 if (!efi_enabled(EFI_PARAVIRT)) {
427 if (efi_enabled(EFI_64BIT))
428 rv = efi_runtime_init64();
429 else
430 rv = efi_runtime_init32();
431
432 if (rv)
433 return rv;
434 }
435
436 set_bit(EFI_RUNTIME_SERVICES, &efi.flags);
437
438 return 0;
439}
440
441static int __init efi_memmap_init(void)
442{
443 if (efi_enabled(EFI_PARAVIRT))
444 return 0;
445
446
447 memmap.map = early_memremap((unsigned long)memmap.phys_map,
448 memmap.nr_map * memmap.desc_size);
449 if (memmap.map == NULL) {
450 pr_err("Could not map the memory map!\n");
451 return -ENOMEM;
452 }
453 memmap.map_end = memmap.map + (memmap.nr_map * memmap.desc_size);
454
455 if (add_efi_memmap)
456 do_add_efi_memmap();
457
458 set_bit(EFI_MEMMAP, &efi.flags);
459
460 return 0;
461}
462
463void __init efi_init(void)
464{
465 efi_char16_t *c16;
466 char vendor[100] = "unknown";
467 int i = 0;
468 void *tmp;
469
470#ifdef CONFIG_X86_32
471 if (boot_params.efi_info.efi_systab_hi ||
472 boot_params.efi_info.efi_memmap_hi) {
473 pr_info("Table located above 4GB, disabling EFI.\n");
474 return;
475 }
476 efi_phys.systab = (efi_system_table_t *)boot_params.efi_info.efi_systab;
477#else
478 efi_phys.systab = (efi_system_table_t *)
479 (boot_params.efi_info.efi_systab |
480 ((__u64)boot_params.efi_info.efi_systab_hi<<32));
481#endif
482
483 if (efi_systab_init(efi_phys.systab))
484 return;
485
486 efi.config_table = (unsigned long)efi.systab->tables;
487 efi.fw_vendor = (unsigned long)efi.systab->fw_vendor;
488 efi.runtime = (unsigned long)efi.systab->runtime;
489
490
491
492
493 c16 = tmp = early_memremap(efi.systab->fw_vendor, 2);
494 if (c16) {
495 for (i = 0; i < sizeof(vendor) - 1 && *c16; ++i)
496 vendor[i] = *c16++;
497 vendor[i] = '\0';
498 } else
499 pr_err("Could not map the firmware vendor!\n");
500 early_memunmap(tmp, 2);
501
502 pr_info("EFI v%u.%.02u by %s\n",
503 efi.systab->hdr.revision >> 16,
504 efi.systab->hdr.revision & 0xffff, vendor);
505
506 if (efi_reuse_config(efi.systab->tables, efi.systab->nr_tables))
507 return;
508
509 if (efi_config_init(arch_tables))
510 return;
511
512
513
514
515
516
517 if (!efi_runtime_supported())
518 pr_info("No EFI runtime due to 32/64-bit mismatch with kernel\n");
519 else {
520 if (efi_runtime_disabled() || efi_runtime_init())
521 return;
522 }
523 if (efi_memmap_init())
524 return;
525
526 if (efi_enabled(EFI_DBG))
527 efi_print_memmap();
528
529 efi_esrt_init();
530}
531
532void __init efi_late_init(void)
533{
534 efi_bgrt_init();
535}
536
537void __init efi_set_executable(efi_memory_desc_t *md, bool executable)
538{
539 u64 addr, npages;
540
541 addr = md->virt_addr;
542 npages = md->num_pages;
543
544 memrange_efi_to_native(&addr, &npages);
545
546 if (executable)
547 set_memory_x(addr, npages);
548 else
549 set_memory_nx(addr, npages);
550}
551
552void __init runtime_code_page_mkexec(void)
553{
554 efi_memory_desc_t *md;
555 void *p;
556
557
558 for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) {
559 md = p;
560
561 if (md->type != EFI_RUNTIME_SERVICES_CODE)
562 continue;
563
564 efi_set_executable(md, true);
565 }
566}
567
568void __init efi_memory_uc(u64 addr, unsigned long size)
569{
570 unsigned long page_shift = 1UL << EFI_PAGE_SHIFT;
571 u64 npages;
572
573 npages = round_up(size, page_shift) / page_shift;
574 memrange_efi_to_native(&addr, &npages);
575 set_memory_uc(addr, npages);
576}
577
578void __init old_map_region(efi_memory_desc_t *md)
579{
580 u64 start_pfn, end_pfn, end;
581 unsigned long size;
582 void *va;
583
584 start_pfn = PFN_DOWN(md->phys_addr);
585 size = md->num_pages << PAGE_SHIFT;
586 end = md->phys_addr + size;
587 end_pfn = PFN_UP(end);
588
589 if (pfn_range_is_mapped(start_pfn, end_pfn)) {
590 va = __va(md->phys_addr);
591
592 if (!(md->attribute & EFI_MEMORY_WB))
593 efi_memory_uc((u64)(unsigned long)va, size);
594 } else
595 va = efi_ioremap(md->phys_addr, size,
596 md->type, md->attribute);
597
598 md->virt_addr = (u64) (unsigned long) va;
599 if (!va)
600 pr_err("ioremap of 0x%llX failed!\n",
601 (unsigned long long)md->phys_addr);
602}
603
604
605static void __init efi_merge_regions(void)
606{
607 void *p;
608 efi_memory_desc_t *md, *prev_md = NULL;
609
610 for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) {
611 u64 prev_size;
612 md = p;
613
614 if (!prev_md) {
615 prev_md = md;
616 continue;
617 }
618
619 if (prev_md->type != md->type ||
620 prev_md->attribute != md->attribute) {
621 prev_md = md;
622 continue;
623 }
624
625 prev_size = prev_md->num_pages << EFI_PAGE_SHIFT;
626
627 if (md->phys_addr == (prev_md->phys_addr + prev_size)) {
628 prev_md->num_pages += md->num_pages;
629 md->type = EFI_RESERVED_TYPE;
630 md->attribute = 0;
631 continue;
632 }
633 prev_md = md;
634 }
635}
636
637static void __init get_systab_virt_addr(efi_memory_desc_t *md)
638{
639 unsigned long size;
640 u64 end, systab;
641
642 size = md->num_pages << EFI_PAGE_SHIFT;
643 end = md->phys_addr + size;
644 systab = (u64)(unsigned long)efi_phys.systab;
645 if (md->phys_addr <= systab && systab < end) {
646 systab += md->virt_addr - md->phys_addr;
647 efi.systab = (efi_system_table_t *)(unsigned long)systab;
648 }
649}
650
651static void __init save_runtime_map(void)
652{
653#ifdef CONFIG_KEXEC_CORE
654 efi_memory_desc_t *md;
655 void *tmp, *p, *q = NULL;
656 int count = 0;
657
658 if (efi_enabled(EFI_OLD_MEMMAP))
659 return;
660
661 for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) {
662 md = p;
663
664 if (!(md->attribute & EFI_MEMORY_RUNTIME) ||
665 (md->type == EFI_BOOT_SERVICES_CODE) ||
666 (md->type == EFI_BOOT_SERVICES_DATA))
667 continue;
668 tmp = krealloc(q, (count + 1) * memmap.desc_size, GFP_KERNEL);
669 if (!tmp)
670 goto out;
671 q = tmp;
672
673 memcpy(q + count * memmap.desc_size, md, memmap.desc_size);
674 count++;
675 }
676
677 efi_runtime_map_setup(q, count, memmap.desc_size);
678 return;
679
680out:
681 kfree(q);
682 pr_err("Error saving runtime map, efi runtime on kexec non-functional!!\n");
683#endif
684}
685
686static void *realloc_pages(void *old_memmap, int old_shift)
687{
688 void *ret;
689
690 ret = (void *)__get_free_pages(GFP_KERNEL, old_shift + 1);
691 if (!ret)
692 goto out;
693
694
695
696
697 if (!old_memmap)
698 return ret;
699
700 memcpy(ret, old_memmap, PAGE_SIZE << old_shift);
701
702out:
703 free_pages((unsigned long)old_memmap, old_shift);
704 return ret;
705}
706
707
708
709
710
711
712
713static inline void *efi_map_next_entry_reverse(void *entry)
714{
715
716 if (!entry)
717 return memmap.map_end - memmap.desc_size;
718
719 entry -= memmap.desc_size;
720 if (entry < memmap.map)
721 return NULL;
722
723 return entry;
724}
725
726
727
728
729
730
731
732
733
734
735
736
737static void *efi_map_next_entry(void *entry)
738{
739 if (!efi_enabled(EFI_OLD_MEMMAP) && efi_enabled(EFI_64BIT)) {
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757 return efi_map_next_entry_reverse(entry);
758 }
759
760
761 if (!entry)
762 return memmap.map;
763
764 entry += memmap.desc_size;
765 if (entry >= memmap.map_end)
766 return NULL;
767
768 return entry;
769}
770
771
772
773
774
775static void * __init efi_map_regions(int *count, int *pg_shift)
776{
777 void *p, *new_memmap = NULL;
778 unsigned long left = 0;
779 efi_memory_desc_t *md;
780
781 p = NULL;
782 while ((p = efi_map_next_entry(p))) {
783 md = p;
784 if (!(md->attribute & EFI_MEMORY_RUNTIME)) {
785#ifdef CONFIG_X86_64
786 if (md->type != EFI_BOOT_SERVICES_CODE &&
787 md->type != EFI_BOOT_SERVICES_DATA)
788#endif
789 continue;
790 }
791
792 efi_map_region(md);
793 get_systab_virt_addr(md);
794
795 if (left < memmap.desc_size) {
796 new_memmap = realloc_pages(new_memmap, *pg_shift);
797 if (!new_memmap)
798 return NULL;
799
800 left += PAGE_SIZE << *pg_shift;
801 (*pg_shift)++;
802 }
803
804 memcpy(new_memmap + (*count * memmap.desc_size), md,
805 memmap.desc_size);
806
807 left -= memmap.desc_size;
808 (*count)++;
809 }
810
811 return new_memmap;
812}
813
814static void __init kexec_enter_virtual_mode(void)
815{
816#ifdef CONFIG_KEXEC_CORE
817 efi_memory_desc_t *md;
818 unsigned int num_pages;
819 void *p;
820
821 efi.systab = NULL;
822
823
824
825
826
827 if (!efi_is_native()) {
828 efi_unmap_memmap();
829 clear_bit(EFI_RUNTIME_SERVICES, &efi.flags);
830 return;
831 }
832
833 if (efi_alloc_page_tables()) {
834 pr_err("Failed to allocate EFI page tables\n");
835 clear_bit(EFI_RUNTIME_SERVICES, &efi.flags);
836 return;
837 }
838
839
840
841
842
843 for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) {
844 md = p;
845 efi_map_region_fixed(md);
846 get_systab_virt_addr(md);
847 }
848
849 save_runtime_map();
850
851 BUG_ON(!efi.systab);
852
853 num_pages = ALIGN(memmap.nr_map * memmap.desc_size, PAGE_SIZE);
854 num_pages >>= PAGE_SHIFT;
855
856 if (efi_setup_page_tables(memmap.phys_map, num_pages)) {
857 clear_bit(EFI_RUNTIME_SERVICES, &efi.flags);
858 return;
859 }
860
861 efi_sync_low_kernel_mappings();
862
863
864
865
866
867
868
869 efi.runtime_version = efi_systab.hdr.revision;
870
871 efi_native_runtime_setup();
872
873 efi.set_virtual_address_map = NULL;
874
875 if (efi_enabled(EFI_OLD_MEMMAP) && (__supported_pte_mask & _PAGE_NX))
876 runtime_code_page_mkexec();
877
878
879 efi_delete_dummy_variable();
880#endif
881}
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905static void __init __efi_enter_virtual_mode(void)
906{
907 int count = 0, pg_shift = 0;
908 void *new_memmap = NULL;
909 efi_status_t status;
910
911 efi.systab = NULL;
912
913 if (efi_alloc_page_tables()) {
914 pr_err("Failed to allocate EFI page tables\n");
915 clear_bit(EFI_RUNTIME_SERVICES, &efi.flags);
916 return;
917 }
918
919 efi_merge_regions();
920 new_memmap = efi_map_regions(&count, &pg_shift);
921 if (!new_memmap) {
922 pr_err("Error reallocating memory, EFI runtime non-functional!\n");
923 clear_bit(EFI_RUNTIME_SERVICES, &efi.flags);
924 return;
925 }
926
927 save_runtime_map();
928
929 BUG_ON(!efi.systab);
930
931 if (efi_setup_page_tables(__pa(new_memmap), 1 << pg_shift)) {
932 clear_bit(EFI_RUNTIME_SERVICES, &efi.flags);
933 return;
934 }
935
936 efi_sync_low_kernel_mappings();
937
938 if (efi_is_native()) {
939 status = phys_efi_set_virtual_address_map(
940 memmap.desc_size * count,
941 memmap.desc_size,
942 memmap.desc_version,
943 (efi_memory_desc_t *)__pa(new_memmap));
944 } else {
945 status = efi_thunk_set_virtual_address_map(
946 efi_phys.set_virtual_address_map,
947 memmap.desc_size * count,
948 memmap.desc_size,
949 memmap.desc_version,
950 (efi_memory_desc_t *)__pa(new_memmap));
951 }
952
953 if (status != EFI_SUCCESS) {
954 pr_alert("Unable to switch EFI into virtual mode (status=%lx)!\n",
955 status);
956 panic("EFI call to SetVirtualAddressMap() failed!");
957 }
958
959
960
961
962
963
964
965 efi.runtime_version = efi_systab.hdr.revision;
966
967 if (efi_is_native())
968 efi_native_runtime_setup();
969 else
970 efi_thunk_runtime_setup();
971
972 efi.set_virtual_address_map = NULL;
973
974
975
976
977
978
979 efi_runtime_update_mappings();
980 efi_dump_pagetable();
981
982
983
984
985
986
987
988
989
990
991 free_pages((unsigned long)new_memmap, pg_shift);
992
993
994 efi_delete_dummy_variable();
995}
996
997void __init efi_enter_virtual_mode(void)
998{
999 if (efi_enabled(EFI_PARAVIRT))
1000 return;
1001
1002 if (efi_setup)
1003 kexec_enter_virtual_mode();
1004 else
1005 __efi_enter_virtual_mode();
1006}
1007
1008
1009
1010
1011u32 efi_mem_type(unsigned long phys_addr)
1012{
1013 efi_memory_desc_t *md;
1014 void *p;
1015
1016 if (!efi_enabled(EFI_MEMMAP))
1017 return 0;
1018
1019 for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) {
1020 md = p;
1021 if ((md->phys_addr <= phys_addr) &&
1022 (phys_addr < (md->phys_addr +
1023 (md->num_pages << EFI_PAGE_SHIFT))))
1024 return md->type;
1025 }
1026 return 0;
1027}
1028
1029static int __init arch_parse_efi_cmdline(char *str)
1030{
1031 if (!str) {
1032 pr_warn("need at least one option\n");
1033 return -EINVAL;
1034 }
1035
1036 if (parse_option_str(str, "old_map"))
1037 set_bit(EFI_OLD_MEMMAP, &efi.flags);
1038
1039 return 0;
1040}
1041early_param("efi", arch_parse_efi_cmdline);
1042