drivers/firmware/efi/efi-init.c

   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                  * Special purpose memory is 'soft reserved', which means it
 148                  * is set aside initially, but can be hotplugged back in or
 149                  * be assigned to the dax driver after boot.
 150                  */
 151                 if (efi_soft_reserve_enabled() &&
 152                     (md->attribute & EFI_MEMORY_SP))
 153                         return false;
 154
 155                 /*
 156                  * According to the spec, these regions are no longer reserved
 157                  * after calling ExitBootServices(). However, we can only use
 158                  * them as System RAM if they can be mapped writeback cacheable.
 159                  */
 160                 return (md->attribute & EFI_MEMORY_WB);
 161         default:
 162                 break;
 163         }
 164         return false;
 165 }
 166
 167 static __init void reserve_regions(void)
 168 {
 169         efi_memory_desc_t *md;
 170         u64 paddr, npages, size;
 171
 172         if (efi_enabled(EFI_DBG))
 173                 pr_info("Processing EFI memory map:\n");
 174
 175         /*
 176          * Discard memblocks discovered so far: if there are any at this
 177          * point, they originate from memory nodes in the DT, and UEFI
 178          * uses its own memory map instead.
 179          */
 180         memblock_dump_all();
 181         memblock_remove(0, PHYS_ADDR_MAX);
 182
 183         for_each_efi_memory_desc(md) {
 184                 paddr = md->phys_addr;
 185                 npages = md->num_pages;
 186
 187                 if (efi_enabled(EFI_DBG)) {
 188                         char buf[64];
 189
 190                         pr_info("  0x%012llx-0x%012llx %s\n",
 191                                 paddr, paddr + (npages << EFI_PAGE_SHIFT) - 1,
 192                                 efi_md_typeattr_format(buf, sizeof(buf), md));
 193                 }
 194
 195                 memrange_efi_to_native(&paddr, &npages);
 196                 size = npages << PAGE_SHIFT;
 197
 198                 if (is_memory(md)) {
 199                         early_init_dt_add_memory_arch(paddr, size);
 200
 201                         if (!is_usable_memory(md))
 202                                 memblock_mark_nomap(paddr, size);
 203
 204                         /* keep ACPI reclaim memory intact for kexec etc. */
 205                         if (md->type == EFI_ACPI_RECLAIM_MEMORY)
 206                                 memblock_reserve(paddr, size);
 207                 }
 208         }
 209 }
 210
 211 void __init efi_init(void)
 212 {
 213         struct efi_memory_map_data data;
 214         u64 efi_system_table;
 215
 216         /* Grab UEFI information placed in FDT by stub */
 217         efi_system_table = efi_get_fdt_params(&data);
 218         if (!efi_system_table)
 219                 return;
 220
 221         if (efi_memmap_init_early(&data) < 0) {
 222                 /*
 223                 * If we are booting via UEFI, the UEFI memory map is the only
 224                 * description of memory we have, so there is little point in
 225                 * proceeding if we cannot access it.
 226                 */
 227                 panic("Unable to map EFI memory map.\n");
 228         }
 229
 230         WARN(efi.memmap.desc_version != 1,
 231              "Unexpected EFI_MEMORY_DESCRIPTOR version %ld",
 232               efi.memmap.desc_version);
 233
 234         if (uefi_init(efi_system_table) < 0) {
 235                 efi_memmap_unmap();
 236                 return;
 237         }
 238
 239         reserve_regions();
 240         /*
 241          * For memblock manipulation, the cap should come after the memblock_add().
 242          * And now, memblock is fully populated, it is time to do capping.
 243          */
 244         early_init_dt_check_for_usable_mem_range();
 245         efi_find_mirror();
 246         efi_esrt_init();
 247         efi_mokvar_table_init();
 248
 249         memblock_reserve(data.phys_map & PAGE_MASK,
 250                          PAGE_ALIGN(data.size + (data.phys_map & ~PAGE_MASK)));
 251
 252         if (IS_ENABLED(CONFIG_X86) ||
 253             IS_ENABLED(CONFIG_SYSFB) ||
 254             IS_ENABLED(CONFIG_EFI_EARLYCON))
 255                 init_screen_info();
 256 }