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)); 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)); 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 case EFI_PERSISTENT_MEMORY: 162 return 0; 163 default: 164 break; 165 } 166 return is_normal_ram(md); 167 } 168 169 static __init void reserve_regions(void) 170 { 171 efi_memory_desc_t *md; 172 u64 paddr, npages, size; 173 174 if (uefi_debug) 175 pr_info("Processing EFI memory map:\n"); 176 177 for_each_efi_memory_desc(&memmap, md) { 178 paddr = md->phys_addr; 179 npages = md->num_pages; 180 181 if (uefi_debug) { 182 char buf[64]; 183 184 pr_info(" 0x%012llx-0x%012llx %s", 185 paddr, paddr + (npages << EFI_PAGE_SHIFT) - 1, 186 efi_md_typeattr_format(buf, sizeof(buf), md)); 187 } 188 189 memrange_efi_to_native(&paddr, &npages); 190 size = npages << PAGE_SHIFT; 191 192 if (is_normal_ram(md)) 193 early_init_dt_add_memory_arch(paddr, size); 194 195 if (is_reserve_region(md)) { 196 memblock_reserve(paddr, size); 197 if (uefi_debug) 198 pr_cont("*"); 199 } 200 201 if (uefi_debug) 202 pr_cont("\n"); 203 } 204 205 set_bit(EFI_MEMMAP, &efi.flags); 206 } 207 208 void __init efi_init(void) 209 { 210 struct efi_fdt_params params; 211 212 /* Grab UEFI information placed in FDT by stub */ 213 if (!efi_get_fdt_params(¶ms, uefi_debug)) 214 return; 215 216 efi_system_table = params.system_table; 217 218 memblock_reserve(params.mmap & PAGE_MASK, 219 PAGE_ALIGN(params.mmap_size + (params.mmap & ~PAGE_MASK))); 220 memmap.phys_map = (void *)params.mmap; 221 memmap.map = early_memremap(params.mmap, params.mmap_size); 222 memmap.map_end = memmap.map + params.mmap_size; 223 memmap.desc_size = params.desc_size; 224 memmap.desc_version = params.desc_ver; 225 226 if (uefi_init() < 0) 227 return; 228 229 reserve_regions(); 230 early_memunmap(memmap.map, params.mmap_size); 231 } 232 233 static bool __init efi_virtmap_init(void) 234 { 235 efi_memory_desc_t *md; 236 237 for_each_efi_memory_desc(&memmap, md) { 238 u64 paddr, npages, size; 239 pgprot_t prot; 240 241 if (!(md->attribute & EFI_MEMORY_RUNTIME)) 242 continue; 243 if (md->virt_addr == 0) 244 return false; 245 246 paddr = md->phys_addr; 247 npages = md->num_pages; 248 memrange_efi_to_native(&paddr, &npages); 249 size = npages << PAGE_SHIFT; 250 251 pr_info(" EFI remap 0x%016llx => %p\n", 252 md->phys_addr, (void *)md->virt_addr); 253 254 /* 255 * Only regions of type EFI_RUNTIME_SERVICES_CODE need to be 256 * executable, everything else can be mapped with the XN bits 257 * set. 258 */ 259 if (!is_normal_ram(md)) 260 prot = __pgprot(PROT_DEVICE_nGnRE); 261 else if (md->type == EFI_RUNTIME_SERVICES_CODE) 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