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 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(¶ms, 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 prot = PAGE_KERNEL_EXEC; 262 else 263 prot = PAGE_KERNEL; 264 265 create_pgd_mapping(&efi_mm, paddr, md->virt_addr, size, prot); 266 } 267 return true; 268 } 269 270 /* 271 * Enable the UEFI Runtime Services if all prerequisites are in place, i.e., 272 * non-early mapping of the UEFI system table and virtual mappings for all 273 * EFI_MEMORY_RUNTIME regions. 274 */ 275 static int __init arm64_enable_runtime_services(void) 276 { 277 u64 mapsize; 278 279 if (!efi_enabled(EFI_BOOT)) { 280 pr_info("EFI services will not be available.\n"); 281 return -1; 282 } 283 284 if (efi_runtime_disabled()) { 285 pr_info("EFI runtime services will be disabled.\n"); 286 return -1; 287 } 288 289 pr_info("Remapping and enabling EFI services.\n"); 290 291 mapsize = memmap.map_end - memmap.map; 292 memmap.map = (__force void *)ioremap_cache((phys_addr_t)memmap.phys_map, 293 mapsize); 294 if (!memmap.map) { 295 pr_err("Failed to remap EFI memory map\n"); 296 return -1; 297 } 298 memmap.map_end = memmap.map + mapsize; 299 efi.memmap = &memmap; 300 301 efi.systab = (__force void *)ioremap_cache(efi_system_table, 302 sizeof(efi_system_table_t)); 303 if (!efi.systab) { 304 pr_err("Failed to remap EFI System Table\n"); 305 return -1; 306 } 307 set_bit(EFI_SYSTEM_TABLES, &efi.flags); 308 309 if (!efi_virtmap_init()) { 310 pr_err("No UEFI virtual mapping was installed -- runtime services will not be available\n"); 311 return -1; 312 } 313 314 /* Set up runtime services function pointers */ 315 efi_native_runtime_setup(); 316 set_bit(EFI_RUNTIME_SERVICES, &efi.flags); 317 318 efi.runtime_version = efi.systab->hdr.revision; 319 320 return 0; 321 } 322 early_initcall(arm64_enable_runtime_services); 323 324 static int __init arm64_dmi_init(void) 325 { 326 /* 327 * On arm64, DMI depends on UEFI, and dmi_scan_machine() needs to 328 * be called early because dmi_id_init(), which is an arch_initcall 329 * itself, depends on dmi_scan_machine() having been called already. 330 */ 331 dmi_scan_machine(); 332 if (dmi_available) 333 dmi_set_dump_stack_arch_desc(); 334 return 0; 335 } 336 core_initcall(arm64_dmi_init); 337 338 static void efi_set_pgd(struct mm_struct *mm) 339 { 340 if (mm == &init_mm) 341 cpu_set_reserved_ttbr0(); 342 else 343 cpu_switch_mm(mm->pgd, mm); 344 345 flush_tlb_all(); 346 if (icache_is_aivivt()) 347 __flush_icache_all(); 348 } 349 350 void efi_virtmap_load(void) 351 { 352 preempt_disable(); 353 efi_set_pgd(&efi_mm); 354 } 355 356 void efi_virtmap_unload(void) 357 { 358 efi_set_pgd(current->active_mm); 359 preempt_enable(); 360 } 361 362 /* 363 * UpdateCapsule() depends on the system being shutdown via 364 * ResetSystem(). 365 */ 366 bool efi_poweroff_required(void) 367 { 368 return efi_enabled(EFI_RUNTIME_SERVICES); 369 } 370