1 // SPDX-License-Identifier: GPL-2.0
3 * Extensible Firmware Interface
5 * Based on Extensible Firmware Interface Specification version 2.4
7 * Copyright (C) 2013 - 2015 Linaro Ltd.
10 #define pr_fmt(fmt) "efi: " fmt
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>
18 #include <linux/of_address.h>
19 #include <linux/of_fdt.h>
20 #include <linux/platform_device.h>
21 #include <linux/screen_info.h>
27 static int __init is_memory(efi_memory_desc_t *md)
29 if (md->attribute & (EFI_MEMORY_WB|EFI_MEMORY_WT|EFI_MEMORY_WC))
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.
39 static phys_addr_t efi_to_phys(unsigned long addr)
41 efi_memory_desc_t *md;
43 for_each_efi_memory_desc(md) {
44 if (!(md->attribute & EFI_MEMORY_RUNTIME))
46 if (md->virt_addr == 0)
47 /* no virtual mapping has been installed by the stub */
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;
56 static __initdata unsigned long screen_info_table = EFI_INVALID_TABLE_ADDR;
58 static __initdata efi_config_table_type_t arch_tables[] = {
59 {LINUX_EFI_ARM_SCREEN_INFO_TABLE_GUID, NULL, &screen_info_table},
60 {NULL_GUID, NULL, NULL}
63 static void __init init_screen_info(void)
65 struct screen_info *si;
67 if (screen_info_table != EFI_INVALID_TABLE_ADDR) {
68 si = early_memremap_ro(screen_info_table, sizeof(*si));
70 pr_err("Could not map screen_info config table\n");
74 early_memunmap(si, sizeof(*si));
76 /* dummycon on ARM needs non-zero values for columns/lines */
77 screen_info.orig_video_cols = 80;
78 screen_info.orig_video_lines = 25;
81 if (screen_info.orig_video_isVGA == VIDEO_TYPE_EFI &&
82 memblock_is_map_memory(screen_info.lfb_base))
83 memblock_mark_nomap(screen_info.lfb_base, screen_info.lfb_size);
86 static int __init uefi_init(void)
91 char vendor[100] = "unknown";
94 efi.systab = early_memremap_ro(efi_system_table,
95 sizeof(efi_system_table_t));
96 if (efi.systab == NULL) {
97 pr_warn("Unable to map EFI system table.\n");
101 set_bit(EFI_BOOT, &efi.flags);
102 if (IS_ENABLED(CONFIG_64BIT))
103 set_bit(EFI_64BIT, &efi.flags);
106 * Verify the EFI Table
108 if (efi.systab->hdr.signature != EFI_SYSTEM_TABLE_SIGNATURE) {
109 pr_err("System table signature incorrect\n");
113 if ((efi.systab->hdr.revision >> 16) < 2)
114 pr_warn("Warning: EFI system table version %d.%02d, expected 2.00 or greater\n",
115 efi.systab->hdr.revision >> 16,
116 efi.systab->hdr.revision & 0xffff);
118 efi.runtime_version = efi.systab->hdr.revision;
120 /* Show what we know for posterity */
121 c16 = early_memremap_ro(efi_to_phys(efi.systab->fw_vendor),
122 sizeof(vendor) * sizeof(efi_char16_t));
124 for (i = 0; i < (int) sizeof(vendor) - 1 && *c16; ++i)
127 early_memunmap(c16, sizeof(vendor) * sizeof(efi_char16_t));
130 pr_info("EFI v%u.%.02u by %s\n",
131 efi.systab->hdr.revision >> 16,
132 efi.systab->hdr.revision & 0xffff, vendor);
134 table_size = sizeof(efi_config_table_64_t) * efi.systab->nr_tables;
135 config_tables = early_memremap_ro(efi_to_phys(efi.systab->tables),
137 if (config_tables == NULL) {
138 pr_warn("Unable to map EFI config table array.\n");
142 retval = efi_config_parse_tables(config_tables, efi.systab->nr_tables,
143 sizeof(efi_config_table_t),
147 efi.config_table = (unsigned long)efi.systab->tables;
149 early_memunmap(config_tables, table_size);
151 early_memunmap(efi.systab, sizeof(efi_system_table_t));
156 * Return true for regions that can be used as System RAM.
158 static __init int is_usable_memory(efi_memory_desc_t *md)
161 case EFI_LOADER_CODE:
162 case EFI_LOADER_DATA:
163 case EFI_ACPI_RECLAIM_MEMORY:
164 case EFI_BOOT_SERVICES_CODE:
165 case EFI_BOOT_SERVICES_DATA:
166 case EFI_CONVENTIONAL_MEMORY:
167 case EFI_PERSISTENT_MEMORY:
169 * Special purpose memory is 'soft reserved', which means it
170 * is set aside initially, but can be hotplugged back in or
171 * be assigned to the dax driver after boot.
173 if (efi_soft_reserve_enabled() &&
174 (md->attribute & EFI_MEMORY_SP))
178 * According to the spec, these regions are no longer reserved
179 * after calling ExitBootServices(). However, we can only use
180 * them as System RAM if they can be mapped writeback cacheable.
182 return (md->attribute & EFI_MEMORY_WB);
189 static __init void reserve_regions(void)
191 efi_memory_desc_t *md;
192 u64 paddr, npages, size;
194 if (efi_enabled(EFI_DBG))
195 pr_info("Processing EFI memory map:\n");
198 * Discard memblocks discovered so far: if there are any at this
199 * point, they originate from memory nodes in the DT, and UEFI
200 * uses its own memory map instead.
203 memblock_remove(0, PHYS_ADDR_MAX);
205 for_each_efi_memory_desc(md) {
206 paddr = md->phys_addr;
207 npages = md->num_pages;
209 if (efi_enabled(EFI_DBG)) {
212 pr_info(" 0x%012llx-0x%012llx %s\n",
213 paddr, paddr + (npages << EFI_PAGE_SHIFT) - 1,
214 efi_md_typeattr_format(buf, sizeof(buf), md));
217 memrange_efi_to_native(&paddr, &npages);
218 size = npages << PAGE_SHIFT;
221 early_init_dt_add_memory_arch(paddr, size);
223 if (!is_usable_memory(md))
224 memblock_mark_nomap(paddr, size);
226 /* keep ACPI reclaim memory intact for kexec etc. */
227 if (md->type == EFI_ACPI_RECLAIM_MEMORY)
228 memblock_reserve(paddr, size);
233 void __init efi_init(void)
235 struct efi_memory_map_data data;
236 struct efi_fdt_params params;
238 /* Grab UEFI information placed in FDT by stub */
239 if (!efi_get_fdt_params(¶ms))
242 efi_system_table = params.system_table;
244 data.desc_version = params.desc_ver;
245 data.desc_size = params.desc_size;
246 data.size = params.mmap_size;
247 data.phys_map = params.mmap;
249 if (efi_memmap_init_early(&data) < 0) {
251 * If we are booting via UEFI, the UEFI memory map is the only
252 * description of memory we have, so there is little point in
253 * proceeding if we cannot access it.
255 panic("Unable to map EFI memory map.\n");
258 WARN(efi.memmap.desc_version != 1,
259 "Unexpected EFI_MEMORY_DESCRIPTOR version %ld",
260 efi.memmap.desc_version);
262 if (uefi_init() < 0) {
270 memblock_reserve(params.mmap & PAGE_MASK,
271 PAGE_ALIGN(params.mmap_size +
272 (params.mmap & ~PAGE_MASK)));
276 /* ARM does not permit early mappings to persist across paging_init() */
277 if (IS_ENABLED(CONFIG_ARM))
281 static bool efifb_overlaps_pci_range(const struct of_pci_range *range)
283 u64 fb_base = screen_info.lfb_base;
285 if (screen_info.capabilities & VIDEO_CAPABILITY_64BIT_BASE)
286 fb_base |= (u64)(unsigned long)screen_info.ext_lfb_base << 32;
288 return fb_base >= range->cpu_addr &&
289 fb_base < (range->cpu_addr + range->size);
292 static struct device_node *find_pci_overlap_node(void)
294 struct device_node *np;
296 for_each_node_by_type(np, "pci") {
297 struct of_pci_range_parser parser;
298 struct of_pci_range range;
301 err = of_pci_range_parser_init(&parser, np);
303 pr_warn("of_pci_range_parser_init() failed: %d\n", err);
307 for_each_of_pci_range(&parser, &range)
308 if (efifb_overlaps_pci_range(&range))
315 * If the efifb framebuffer is backed by a PCI graphics controller, we have
316 * to ensure that this relation is expressed using a device link when
317 * running in DT mode, or the probe order may be reversed, resulting in a
318 * resource reservation conflict on the memory window that the efifb
319 * framebuffer steals from the PCIe host bridge.
321 static int efifb_add_links(const struct fwnode_handle *fwnode,
324 struct device_node *sup_np;
325 struct device *sup_dev;
327 sup_np = find_pci_overlap_node();
330 * If there's no PCI graphics controller backing the efifb, we are
336 sup_dev = get_dev_from_fwnode(&sup_np->fwnode);
340 * Return -ENODEV if the PCI graphics controller device hasn't been
341 * registered yet. This ensures that efifb isn't allowed to probe
342 * and this function is retried again when new devices are
349 * If this fails, retrying this function at a later point won't
350 * change anything. So, don't return an error after this.
352 if (!device_link_add(dev, sup_dev, 0))
353 dev_warn(dev, "device_link_add() failed\n");
360 static const struct fwnode_operations efifb_fwnode_ops = {
361 .add_links = efifb_add_links,
364 static struct fwnode_handle efifb_fwnode = {
365 .ops = &efifb_fwnode_ops,
368 static int __init register_gop_device(void)
370 struct platform_device *pd;
373 if (screen_info.orig_video_isVGA != VIDEO_TYPE_EFI)
376 pd = platform_device_alloc("efi-framebuffer", 0);
380 if (IS_ENABLED(CONFIG_PCI))
381 pd->dev.fwnode = &efifb_fwnode;
383 err = platform_device_add_data(pd, &screen_info, sizeof(screen_info));
387 return platform_device_add(pd);
389 subsys_initcall(register_gop_device);