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 static void __init init_screen_info(void)
  59 {
  60         struct screen_info *si;
  61
  62         if (screen_info_table != EFI_INVALID_TABLE_ADDR) {
  63                 si = early_memremap(screen_info_table, sizeof(*si));
  64                 if (!si) {
  65                         pr_err("Could not map screen_info config table\n");
  66                         return;
  67                 }
  68                 screen_info = *si;
  69                 memset(si, 0, sizeof(*si));
  70                 early_memunmap(si, sizeof(*si));
  71
  72                 if (memblock_is_map_memory(screen_info.lfb_base))
  73                         memblock_mark_nomap(screen_info.lfb_base,
  74                                             screen_info.lfb_size);
  75
  76                 if (IS_ENABLED(CONFIG_EFI_EARLYCON))
  77                         efi_earlycon_reprobe();
  78         }
  79 }
  80
  81 static int __init uefi_init(u64 efi_system_table)
  82 {
  83         efi_config_table_t *config_tables;
  84         efi_system_table_t *systab;
  85         size_t table_size;
  86         int retval;
  87
  88         systab = early_memremap_ro(efi_system_table, sizeof(efi_system_table_t));
  89         if (systab == NULL) {
  90                 pr_warn("Unable to map EFI system table.\n");
  91                 return -ENOMEM;
  92         }
  93
  94         set_bit(EFI_BOOT, &efi.flags);
  95         if (IS_ENABLED(CONFIG_64BIT))
  96                 set_bit(EFI_64BIT, &efi.flags);
  97
  98         retval = efi_systab_check_header(&systab->hdr);
  99         if (retval)
 100                 goto out;
 101
 102         efi.runtime = systab->runtime;
 103         efi.runtime_version = systab->hdr.revision;
 104
 105         efi_systab_report_header(&systab->hdr, efi_to_phys(systab->fw_vendor));
 106
 107         table_size = sizeof(efi_config_table_t) * systab->nr_tables;
 108         config_tables = early_memremap_ro(efi_to_phys(systab->tables),
 109                                           table_size);
 110         if (config_tables == NULL) {
 111                 pr_warn("Unable to map EFI config table array.\n");
 112                 retval = -ENOMEM;
 113                 goto out;
 114         }
 115         retval = efi_config_parse_tables(config_tables, systab->nr_tables,
 116                                          efi_arch_tables);
 117
 118         early_memunmap(config_tables, table_size);
 119 out:
 120         early_memunmap(systab, sizeof(efi_system_table_t));
 121         return retval;
 122 }
 123
 124 /*
 125  * Return true for regions that can be used as System RAM.
 126  */
 127 static __init int is_usable_memory(efi_memory_desc_t *md)
 128 {
 129         switch (md->type) {
 130         case EFI_LOADER_CODE:
 131         case EFI_LOADER_DATA:
 132         case EFI_ACPI_RECLAIM_MEMORY:
 133         case EFI_BOOT_SERVICES_CODE:
 134         case EFI_BOOT_SERVICES_DATA:
 135         case EFI_CONVENTIONAL_MEMORY:
 136         case EFI_PERSISTENT_MEMORY:
 137                 /*
 138                  * Special purpose memory is 'soft reserved', which means it
 139                  * is set aside initially, but can be hotplugged back in or
 140                  * be assigned to the dax driver after boot.
 141                  */
 142                 if (efi_soft_reserve_enabled() &&
 143                     (md->attribute & EFI_MEMORY_SP))
 144                         return false;
 145
 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                         early_init_dt_add_memory_arch(paddr, size);
 191
 192                         if (!is_usable_memory(md))
 193                                 memblock_mark_nomap(paddr, size);
 194
 195                         /* keep ACPI reclaim memory intact for kexec etc. */
 196                         if (md->type == EFI_ACPI_RECLAIM_MEMORY)
 197                                 memblock_reserve(paddr, size);
 198                 }
 199         }
 200 }
 201
 202 void __init efi_init(void)
 203 {
 204         struct efi_memory_map_data data;
 205         u64 efi_system_table;
 206
 207         /* Grab UEFI information placed in FDT by stub */
 208         efi_system_table = efi_get_fdt_params(&data);
 209         if (!efi_system_table)
 210                 return;
 211
 212         if (efi_memmap_init_early(&data) < 0) {
 213                 /*
 214                 * If we are booting via UEFI, the UEFI memory map is the only
 215                 * description of memory we have, so there is little point in
 216                 * proceeding if we cannot access it.
 217                 */
 218                 panic("Unable to map EFI memory map.\n");
 219         }
 220
 221         WARN(efi.memmap.desc_version != 1,
 222              "Unexpected EFI_MEMORY_DESCRIPTOR version %ld",
 223               efi.memmap.desc_version);
 224
 225         if (uefi_init(efi_system_table) < 0) {
 226                 efi_memmap_unmap();
 227                 return;
 228         }
 229
 230         reserve_regions();
 231         /*
 232          * For memblock manipulation, the cap should come after the memblock_add().
 233          * And now, memblock is fully populated, it is time to do capping.
 234          */
 235         early_init_dt_check_for_usable_mem_range();
 236         efi_find_mirror();
 237         efi_esrt_init();
 238         efi_mokvar_table_init();
 239
 240         memblock_reserve(data.phys_map & PAGE_MASK,
 241                          PAGE_ALIGN(data.size + (data.phys_map & ~PAGE_MASK)));
 242
 243         init_screen_info();
 244 }