1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Extensible Firmware Interface 4 * 5 * Based on Extensible Firmware Interface Specification version 2.4 6 * 7 * Copyright (C) 2013 - 2015 Linaro Ltd. 8 */ 9 10 #define pr_fmt(fmt) "efi: " fmt 11 12 #include <linux/efi.h> 13 #include <linux/fwnode.h> 14 #include <linux/init.h> 15 #include <linux/memblock.h> 16 #include <linux/mm_types.h> 17 #include <linux/of.h> 18 #include <linux/of_address.h> 19 #include <linux/of_fdt.h> 20 #include <linux/platform_device.h> 21 #include <linux/screen_info.h> 22 23 #include <asm/efi.h> 24 25 unsigned long __initdata screen_info_table = EFI_INVALID_TABLE_ADDR; 26 27 static int __init is_memory(efi_memory_desc_t *md) 28 { 29 if (md->attribute & (EFI_MEMORY_WB|EFI_MEMORY_WT|EFI_MEMORY_WC)) 30 return 1; 31 return 0; 32 } 33 34 /* 35 * Translate a EFI virtual address into a physical address: this is necessary, 36 * as some data members of the EFI system table are virtually remapped after 37 * SetVirtualAddressMap() has been called. 38 */ 39 static phys_addr_t __init efi_to_phys(unsigned long addr) 40 { 41 efi_memory_desc_t *md; 42 43 for_each_efi_memory_desc(md) { 44 if (!(md->attribute & EFI_MEMORY_RUNTIME)) 45 continue; 46 if (md->virt_addr == 0) 47 /* no virtual mapping has been installed by the stub */ 48 break; 49 if (md->virt_addr <= addr && 50 (addr - md->virt_addr) < (md->num_pages << EFI_PAGE_SHIFT)) 51 return md->phys_addr + addr - md->virt_addr; 52 } 53 return addr; 54 } 55 56 extern __weak const efi_config_table_type_t efi_arch_tables[]; 57 58 /* 59 * x86 defines its own screen_info and uses it even without EFI, 60 * everything else can get it from here. 61 */ 62 #if !defined(CONFIG_X86) && (defined(CONFIG_SYSFB) || defined(CONFIG_EFI_EARLYCON)) 63 struct screen_info screen_info __section(".data"); 64 EXPORT_SYMBOL_GPL(screen_info); 65 #endif 66 67 static void __init init_screen_info(void) 68 { 69 struct screen_info *si; 70 71 if (screen_info_table != EFI_INVALID_TABLE_ADDR) { 72 si = early_memremap(screen_info_table, sizeof(*si)); 73 if (!si) { 74 pr_err("Could not map screen_info config table\n"); 75 return; 76 } 77 screen_info = *si; 78 memset(si, 0, sizeof(*si)); 79 early_memunmap(si, sizeof(*si)); 80 81 if (memblock_is_map_memory(screen_info.lfb_base)) 82 memblock_mark_nomap(screen_info.lfb_base, 83 screen_info.lfb_size); 84 85 if (IS_ENABLED(CONFIG_EFI_EARLYCON)) 86 efi_earlycon_reprobe(); 87 } 88 } 89 90 static int __init uefi_init(u64 efi_system_table) 91 { 92 efi_config_table_t *config_tables; 93 efi_system_table_t *systab; 94 size_t table_size; 95 int retval; 96 97 systab = early_memremap_ro(efi_system_table, sizeof(efi_system_table_t)); 98 if (systab == NULL) { 99 pr_warn("Unable to map EFI system table.\n"); 100 return -ENOMEM; 101 } 102 103 set_bit(EFI_BOOT, &efi.flags); 104 if (IS_ENABLED(CONFIG_64BIT)) 105 set_bit(EFI_64BIT, &efi.flags); 106 107 retval = efi_systab_check_header(&systab->hdr); 108 if (retval) 109 goto out; 110 111 efi.runtime = systab->runtime; 112 efi.runtime_version = systab->hdr.revision; 113 114 efi_systab_report_header(&systab->hdr, efi_to_phys(systab->fw_vendor)); 115 116 table_size = sizeof(efi_config_table_t) * systab->nr_tables; 117 config_tables = early_memremap_ro(efi_to_phys(systab->tables), 118 table_size); 119 if (config_tables == NULL) { 120 pr_warn("Unable to map EFI config table array.\n"); 121 retval = -ENOMEM; 122 goto out; 123 } 124 retval = efi_config_parse_tables(config_tables, systab->nr_tables, 125 efi_arch_tables); 126 127 early_memunmap(config_tables, table_size); 128 out: 129 early_memunmap(systab, sizeof(efi_system_table_t)); 130 return retval; 131 } 132 133 /* 134 * Return true for regions that can be used as System RAM. 135 */ 136 static __init int is_usable_memory(efi_memory_desc_t *md) 137 { 138 switch (md->type) { 139 case EFI_LOADER_CODE: 140 case EFI_LOADER_DATA: 141 case EFI_ACPI_RECLAIM_MEMORY: 142 case EFI_BOOT_SERVICES_CODE: 143 case EFI_BOOT_SERVICES_DATA: 144 case EFI_CONVENTIONAL_MEMORY: 145 case EFI_PERSISTENT_MEMORY: 146 /* 147 * According to the spec, these regions are no longer reserved 148 * after calling ExitBootServices(). However, we can only use 149 * them as System RAM if they can be mapped writeback cacheable. 150 */ 151 return (md->attribute & EFI_MEMORY_WB); 152 default: 153 break; 154 } 155 return false; 156 } 157 158 static __init void reserve_regions(void) 159 { 160 efi_memory_desc_t *md; 161 u64 paddr, npages, size; 162 163 if (efi_enabled(EFI_DBG)) 164 pr_info("Processing EFI memory map:\n"); 165 166 /* 167 * Discard memblocks discovered so far: if there are any at this 168 * point, they originate from memory nodes in the DT, and UEFI 169 * uses its own memory map instead. 170 */ 171 memblock_dump_all(); 172 memblock_remove(0, PHYS_ADDR_MAX); 173 174 for_each_efi_memory_desc(md) { 175 paddr = md->phys_addr; 176 npages = md->num_pages; 177 178 if (efi_enabled(EFI_DBG)) { 179 char buf[64]; 180 181 pr_info(" 0x%012llx-0x%012llx %s\n", 182 paddr, paddr + (npages << EFI_PAGE_SHIFT) - 1, 183 efi_md_typeattr_format(buf, sizeof(buf), md)); 184 } 185 186 memrange_efi_to_native(&paddr, &npages); 187 size = npages << PAGE_SHIFT; 188 189 if (is_memory(md)) { 190 /* 191 * Special purpose memory is 'soft reserved', which 192 * means it is set aside initially. Don't add a memblock 193 * for it now so that it can be hotplugged back in or 194 * be assigned to the dax driver after boot. 195 */ 196 if (efi_soft_reserve_enabled() && 197 (md->attribute & EFI_MEMORY_SP)) 198 continue; 199 200 early_init_dt_add_memory_arch(paddr, size); 201 202 if (!is_usable_memory(md)) 203 memblock_mark_nomap(paddr, size); 204 205 /* keep ACPI reclaim memory intact for kexec etc. */ 206 if (md->type == EFI_ACPI_RECLAIM_MEMORY) 207 memblock_reserve(paddr, size); 208 } 209 } 210 } 211 212 void __init efi_init(void) 213 { 214 struct efi_memory_map_data data; 215 u64 efi_system_table; 216 217 /* Grab UEFI information placed in FDT by stub */ 218 efi_system_table = efi_get_fdt_params(&data); 219 if (!efi_system_table) 220 return; 221 222 if (efi_memmap_init_early(&data) < 0) { 223 /* 224 * If we are booting via UEFI, the UEFI memory map is the only 225 * description of memory we have, so there is little point in 226 * proceeding if we cannot access it. 227 */ 228 panic("Unable to map EFI memory map.\n"); 229 } 230 231 WARN(efi.memmap.desc_version != 1, 232 "Unexpected EFI_MEMORY_DESCRIPTOR version %ld", 233 efi.memmap.desc_version); 234 235 if (uefi_init(efi_system_table) < 0) { 236 efi_memmap_unmap(); 237 return; 238 } 239 240 reserve_regions(); 241 /* 242 * For memblock manipulation, the cap should come after the memblock_add(). 243 * And now, memblock is fully populated, it is time to do capping. 244 */ 245 early_init_dt_check_for_usable_mem_range(); 246 efi_find_mirror(); 247 efi_esrt_init(); 248 efi_mokvar_table_init(); 249 250 memblock_reserve(data.phys_map & PAGE_MASK, 251 PAGE_ALIGN(data.size + (data.phys_map & ~PAGE_MASK))); 252 253 if (IS_ENABLED(CONFIG_X86) || 254 IS_ENABLED(CONFIG_SYSFB) || 255 IS_ENABLED(CONFIG_EFI_EARLYCON)) 256 init_screen_info(); 257 } 258