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