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(phys_addr: screen_info_table, size: 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(addr: si, size: sizeof(*si)); |
80 | |
81 | if (memblock_is_map_memory(addr: screen_info.lfb_base)) |
82 | memblock_mark_nomap(base: screen_info.lfb_base, |
83 | size: 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(phys_addr: efi_system_table, size: 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, addr: &efi.flags); |
104 | if (IS_ENABLED(CONFIG_64BIT)) |
105 | set_bit(EFI_64BIT, addr: &efi.flags); |
106 | |
107 | retval = efi_systab_check_header(systab_hdr: &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: &systab->hdr, fw_vendor: efi_to_phys(addr: systab->fw_vendor)); |
115 | |
116 | table_size = sizeof(efi_config_table_t) * systab->nr_tables; |
117 | config_tables = early_memremap_ro(phys_addr: efi_to_phys(addr: systab->tables), |
118 | size: 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, count: systab->nr_tables, |
125 | arch_tables: efi_arch_tables); |
126 | |
127 | early_memunmap(addr: config_tables, size: table_size); |
128 | out: |
129 | early_memunmap(addr: systab, size: 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(base: 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(addr: &paddr, npages: &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(base: paddr, size); |
201 | |
202 | if (!is_usable_memory(md)) |
203 | memblock_mark_nomap(base: paddr, size); |
204 | |
205 | /* keep ACPI reclaim memory intact for kexec etc. */ |
206 | if (md->type == EFI_ACPI_RECLAIM_MEMORY) |
207 | memblock_reserve(base: 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: &data); |
219 | if (!efi_system_table) |
220 | return; |
221 | |
222 | if (efi_memmap_init_early(data: &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(fmt: "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(base: 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 | |