~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/arm64/kernel/efi.c

Version: ~ [ linux-5.4-rc7 ] ~ [ linux-5.3.10 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.83 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.153 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.200 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.200 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.76 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * Extensible Firmware Interface
  3  *
  4  * Based on Extensible Firmware Interface Specification version 2.4
  5  *
  6  * Copyright (C) 2013, 2014 Linaro Ltd.
  7  *
  8  * This program is free software; you can redistribute it and/or modify
  9  * it under the terms of the GNU General Public License version 2 as
 10  * published by the Free Software Foundation.
 11  *
 12  */
 13 
 14 #include <linux/atomic.h>
 15 #include <linux/dmi.h>
 16 #include <linux/efi.h>
 17 #include <linux/export.h>
 18 #include <linux/memblock.h>
 19 #include <linux/mm_types.h>
 20 #include <linux/bootmem.h>
 21 #include <linux/of.h>
 22 #include <linux/of_fdt.h>
 23 #include <linux/preempt.h>
 24 #include <linux/rbtree.h>
 25 #include <linux/rwsem.h>
 26 #include <linux/sched.h>
 27 #include <linux/slab.h>
 28 #include <linux/spinlock.h>
 29 
 30 #include <asm/cacheflush.h>
 31 #include <asm/efi.h>
 32 #include <asm/tlbflush.h>
 33 #include <asm/mmu_context.h>
 34 #include <asm/mmu.h>
 35 #include <asm/pgtable.h>
 36 
 37 struct efi_memory_map memmap;
 38 
 39 static u64 efi_system_table;
 40 
 41 static pgd_t efi_pgd[PTRS_PER_PGD] __page_aligned_bss;
 42 
 43 static struct mm_struct efi_mm = {
 44         .mm_rb                  = RB_ROOT,
 45         .pgd                    = efi_pgd,
 46         .mm_users               = ATOMIC_INIT(2),
 47         .mm_count               = ATOMIC_INIT(1),
 48         .mmap_sem               = __RWSEM_INITIALIZER(efi_mm.mmap_sem),
 49         .page_table_lock        = __SPIN_LOCK_UNLOCKED(efi_mm.page_table_lock),
 50         .mmlist                 = LIST_HEAD_INIT(efi_mm.mmlist),
 51         INIT_MM_CONTEXT(efi_mm)
 52 };
 53 
 54 static int uefi_debug __initdata;
 55 static int __init uefi_debug_setup(char *str)
 56 {
 57         uefi_debug = 1;
 58 
 59         return 0;
 60 }
 61 early_param("uefi_debug", uefi_debug_setup);
 62 
 63 static int __init is_normal_ram(efi_memory_desc_t *md)
 64 {
 65         if (md->attribute & EFI_MEMORY_WB)
 66                 return 1;
 67         return 0;
 68 }
 69 
 70 /*
 71  * Translate a EFI virtual address into a physical address: this is necessary,
 72  * as some data members of the EFI system table are virtually remapped after
 73  * SetVirtualAddressMap() has been called.
 74  */
 75 static phys_addr_t efi_to_phys(unsigned long addr)
 76 {
 77         efi_memory_desc_t *md;
 78 
 79         for_each_efi_memory_desc(&memmap, md) {
 80                 if (!(md->attribute & EFI_MEMORY_RUNTIME))
 81                         continue;
 82                 if (md->virt_addr == 0)
 83                         /* no virtual mapping has been installed by the stub */
 84                         break;
 85                 if (md->virt_addr <= addr &&
 86                     (addr - md->virt_addr) < (md->num_pages << EFI_PAGE_SHIFT))
 87                         return md->phys_addr + addr - md->virt_addr;
 88         }
 89         return addr;
 90 }
 91 
 92 static int __init uefi_init(void)
 93 {
 94         efi_char16_t *c16;
 95         void *config_tables;
 96         u64 table_size;
 97         char vendor[100] = "unknown";
 98         int i, retval;
 99 
100         efi.systab = early_memremap(efi_system_table,
101                                     sizeof(efi_system_table_t));
102         if (efi.systab == NULL) {
103                 pr_warn("Unable to map EFI system table.\n");
104                 return -ENOMEM;
105         }
106 
107         set_bit(EFI_BOOT, &efi.flags);
108         set_bit(EFI_64BIT, &efi.flags);
109 
110         /*
111          * Verify the EFI Table
112          */
113         if (efi.systab->hdr.signature != EFI_SYSTEM_TABLE_SIGNATURE) {
114                 pr_err("System table signature incorrect\n");
115                 retval = -EINVAL;
116                 goto out;
117         }
118         if ((efi.systab->hdr.revision >> 16) < 2)
119                 pr_warn("Warning: EFI system table version %d.%02d, expected 2.00 or greater\n",
120                         efi.systab->hdr.revision >> 16,
121                         efi.systab->hdr.revision & 0xffff);
122 
123         /* Show what we know for posterity */
124         c16 = early_memremap(efi_to_phys(efi.systab->fw_vendor),
125                              sizeof(vendor) * sizeof(efi_char16_t));
126         if (c16) {
127                 for (i = 0; i < (int) sizeof(vendor) - 1 && *c16; ++i)
128                         vendor[i] = c16[i];
129                 vendor[i] = '\0';
130                 early_memunmap(c16, sizeof(vendor) * sizeof(efi_char16_t));
131         }
132 
133         pr_info("EFI v%u.%.02u by %s\n",
134                 efi.systab->hdr.revision >> 16,
135                 efi.systab->hdr.revision & 0xffff, vendor);
136 
137         table_size = sizeof(efi_config_table_64_t) * efi.systab->nr_tables;
138         config_tables = early_memremap(efi_to_phys(efi.systab->tables),
139                                        table_size);
140 
141         retval = efi_config_parse_tables(config_tables, efi.systab->nr_tables,
142                                          sizeof(efi_config_table_64_t), NULL);
143 
144         early_memunmap(config_tables, table_size);
145 out:
146         early_memunmap(efi.systab,  sizeof(efi_system_table_t));
147         return retval;
148 }
149 
150 /*
151  * Return true for RAM regions we want to permanently reserve.
152  */
153 static __init int is_reserve_region(efi_memory_desc_t *md)
154 {
155         switch (md->type) {
156         case EFI_LOADER_CODE:
157         case EFI_LOADER_DATA:
158         case EFI_BOOT_SERVICES_CODE:
159         case EFI_BOOT_SERVICES_DATA:
160         case EFI_CONVENTIONAL_MEMORY:
161                 return 0;
162         default:
163                 break;
164         }
165         return is_normal_ram(md);
166 }
167 
168 static __init void reserve_regions(void)
169 {
170         efi_memory_desc_t *md;
171         u64 paddr, npages, size;
172 
173         if (uefi_debug)
174                 pr_info("Processing EFI memory map:\n");
175 
176         for_each_efi_memory_desc(&memmap, md) {
177                 paddr = md->phys_addr;
178                 npages = md->num_pages;
179 
180                 if (uefi_debug) {
181                         char buf[64];
182 
183                         pr_info("  0x%012llx-0x%012llx %s",
184                                 paddr, paddr + (npages << EFI_PAGE_SHIFT) - 1,
185                                 efi_md_typeattr_format(buf, sizeof(buf), md));
186                 }
187 
188                 memrange_efi_to_native(&paddr, &npages);
189                 size = npages << PAGE_SHIFT;
190 
191                 if (is_normal_ram(md))
192                         early_init_dt_add_memory_arch(paddr, size);
193 
194                 if (is_reserve_region(md)) {
195                         memblock_reserve(paddr, size);
196                         if (uefi_debug)
197                                 pr_cont("*");
198                 }
199 
200                 if (uefi_debug)
201                         pr_cont("\n");
202         }
203 
204         set_bit(EFI_MEMMAP, &efi.flags);
205 }
206 
207 void __init efi_init(void)
208 {
209         struct efi_fdt_params params;
210 
211         /* Grab UEFI information placed in FDT by stub */
212         if (!efi_get_fdt_params(&params, uefi_debug))
213                 return;
214 
215         efi_system_table = params.system_table;
216 
217         memblock_reserve(params.mmap & PAGE_MASK,
218                          PAGE_ALIGN(params.mmap_size + (params.mmap & ~PAGE_MASK)));
219         memmap.phys_map = (void *)params.mmap;
220         memmap.map = early_memremap(params.mmap, params.mmap_size);
221         memmap.map_end = memmap.map + params.mmap_size;
222         memmap.desc_size = params.desc_size;
223         memmap.desc_version = params.desc_ver;
224 
225         if (uefi_init() < 0)
226                 return;
227 
228         reserve_regions();
229         early_memunmap(memmap.map, params.mmap_size);
230 }
231 
232 static bool __init efi_virtmap_init(void)
233 {
234         efi_memory_desc_t *md;
235 
236         for_each_efi_memory_desc(&memmap, md) {
237                 u64 paddr, npages, size;
238                 pgprot_t prot;
239 
240                 if (!(md->attribute & EFI_MEMORY_RUNTIME))
241                         continue;
242                 if (md->virt_addr == 0)
243                         return false;
244 
245                 paddr = md->phys_addr;
246                 npages = md->num_pages;
247                 memrange_efi_to_native(&paddr, &npages);
248                 size = npages << PAGE_SHIFT;
249 
250                 pr_info("  EFI remap 0x%016llx => %p\n",
251                         md->phys_addr, (void *)md->virt_addr);
252 
253                 /*
254                  * Only regions of type EFI_RUNTIME_SERVICES_CODE need to be
255                  * executable, everything else can be mapped with the XN bits
256                  * set.
257                  */
258                 if (!is_normal_ram(md))
259                         prot = __pgprot(PROT_DEVICE_nGnRE);
260                 else if (md->type == EFI_RUNTIME_SERVICES_CODE ||
261                          !PAGE_ALIGNED(md->phys_addr))
262                         prot = PAGE_KERNEL_EXEC;
263                 else
264                         prot = PAGE_KERNEL;
265 
266                 create_pgd_mapping(&efi_mm, paddr, md->virt_addr, size, prot);
267         }
268         return true;
269 }
270 
271 /*
272  * Enable the UEFI Runtime Services if all prerequisites are in place, i.e.,
273  * non-early mapping of the UEFI system table and virtual mappings for all
274  * EFI_MEMORY_RUNTIME regions.
275  */
276 static int __init arm64_enable_runtime_services(void)
277 {
278         u64 mapsize;
279 
280         if (!efi_enabled(EFI_BOOT)) {
281                 pr_info("EFI services will not be available.\n");
282                 return -1;
283         }
284 
285         if (efi_runtime_disabled()) {
286                 pr_info("EFI runtime services will be disabled.\n");
287                 return -1;
288         }
289 
290         pr_info("Remapping and enabling EFI services.\n");
291 
292         mapsize = memmap.map_end - memmap.map;
293         memmap.map = (__force void *)ioremap_cache((phys_addr_t)memmap.phys_map,
294                                                    mapsize);
295         if (!memmap.map) {
296                 pr_err("Failed to remap EFI memory map\n");
297                 return -1;
298         }
299         memmap.map_end = memmap.map + mapsize;
300         efi.memmap = &memmap;
301 
302         efi.systab = (__force void *)ioremap_cache(efi_system_table,
303                                                    sizeof(efi_system_table_t));
304         if (!efi.systab) {
305                 pr_err("Failed to remap EFI System Table\n");
306                 return -1;
307         }
308         set_bit(EFI_SYSTEM_TABLES, &efi.flags);
309 
310         if (!efi_virtmap_init()) {
311                 pr_err("No UEFI virtual mapping was installed -- runtime services will not be available\n");
312                 return -1;
313         }
314 
315         /* Set up runtime services function pointers */
316         efi_native_runtime_setup();
317         set_bit(EFI_RUNTIME_SERVICES, &efi.flags);
318 
319         efi.runtime_version = efi.systab->hdr.revision;
320 
321         return 0;
322 }
323 early_initcall(arm64_enable_runtime_services);
324 
325 static int __init arm64_dmi_init(void)
326 {
327         /*
328          * On arm64, DMI depends on UEFI, and dmi_scan_machine() needs to
329          * be called early because dmi_id_init(), which is an arch_initcall
330          * itself, depends on dmi_scan_machine() having been called already.
331          */
332         dmi_scan_machine();
333         if (dmi_available)
334                 dmi_set_dump_stack_arch_desc();
335         return 0;
336 }
337 core_initcall(arm64_dmi_init);
338 
339 static void efi_set_pgd(struct mm_struct *mm)
340 {
341         if (mm == &init_mm)
342                 cpu_set_reserved_ttbr0();
343         else
344                 cpu_switch_mm(mm->pgd, mm);
345 
346         flush_tlb_all();
347         if (icache_is_aivivt())
348                 __flush_icache_all();
349 }
350 
351 void efi_virtmap_load(void)
352 {
353         preempt_disable();
354         efi_set_pgd(&efi_mm);
355 }
356 
357 void efi_virtmap_unload(void)
358 {
359         efi_set_pgd(current->active_mm);
360         preempt_enable();
361 }
362 
363 /*
364  * UpdateCapsule() depends on the system being shutdown via
365  * ResetSystem().
366  */
367 bool efi_poweroff_required(void)
368 {
369         return efi_enabled(EFI_RUNTIME_SERVICES);
370 }
371 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp