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