drivers/firmware/efi/efi.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * efi.c - EFI subsystem
   4  *
   5  * Copyright (C) 2001,2003,2004 Dell <Matt_Domsch@dell.com>
   6  * Copyright (C) 2004 Intel Corporation <matthew.e.tolentino@intel.com>
   7  * Copyright (C) 2013 Tom Gundersen <teg@jklm.no>
   8  *
   9  * This code registers /sys/firmware/efi{,/efivars} when EFI is supported,
  10  * allowing the efivarfs to be mounted or the efivars module to be loaded.
  11  * The existance of /sys/firmware/efi may also be used by userspace to
  12  * determine that the system supports EFI.
  13  */
  14
  15 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  16
  17 #include <linux/kobject.h>
  18 #include <linux/module.h>
  19 #include <linux/init.h>
  20 #include <linux/device.h>
  21 #include <linux/efi.h>
  22 #include <linux/of.h>
  23 #include <linux/of_fdt.h>
  24 #include <linux/io.h>
  25 #include <linux/kexec.h>
  26 #include <linux/platform_device.h>
  27 #include <linux/random.h>
  28 #include <linux/reboot.h>
  29 #include <linux/slab.h>
  30 #include <linux/acpi.h>
  31 #include <linux/ucs2_string.h>
  32 #include <linux/memblock.h>
  33
  34 #include <asm/early_ioremap.h>
  35
  36 struct efi __read_mostly efi = {
  37         .mps                    = EFI_INVALID_TABLE_ADDR,
  38         .acpi                   = EFI_INVALID_TABLE_ADDR,
  39         .acpi20                 = EFI_INVALID_TABLE_ADDR,
  40         .smbios                 = EFI_INVALID_TABLE_ADDR,
  41         .smbios3                = EFI_INVALID_TABLE_ADDR,
  42         .boot_info              = EFI_INVALID_TABLE_ADDR,
  43         .hcdp                   = EFI_INVALID_TABLE_ADDR,
  44         .uga                    = EFI_INVALID_TABLE_ADDR,
  45         .fw_vendor              = EFI_INVALID_TABLE_ADDR,
  46         .runtime                = EFI_INVALID_TABLE_ADDR,
  47         .config_table           = EFI_INVALID_TABLE_ADDR,
  48         .esrt                   = EFI_INVALID_TABLE_ADDR,
  49         .properties_table       = EFI_INVALID_TABLE_ADDR,
  50         .mem_attr_table         = EFI_INVALID_TABLE_ADDR,
  51         .rng_seed               = EFI_INVALID_TABLE_ADDR,
  52         .tpm_log                = EFI_INVALID_TABLE_ADDR,
  53         .tpm_final_log          = EFI_INVALID_TABLE_ADDR,
  54         .mem_reserve            = EFI_INVALID_TABLE_ADDR,
  55 };
  56 EXPORT_SYMBOL(efi);
  57
  58 struct mm_struct efi_mm = {
  59         .mm_rb                  = RB_ROOT,
  60         .mm_users               = ATOMIC_INIT(2),
  61         .mm_count               = ATOMIC_INIT(1),
  62         .mmap_sem               = __RWSEM_INITIALIZER(efi_mm.mmap_sem),
  63         .page_table_lock        = __SPIN_LOCK_UNLOCKED(efi_mm.page_table_lock),
  64         .mmlist                 = LIST_HEAD_INIT(efi_mm.mmlist),
  65         .cpu_bitmap             = { [BITS_TO_LONGS(NR_CPUS)] = 0},
  66 };
  67
  68 struct workqueue_struct *efi_rts_wq;
  69
  70 static bool disable_runtime;
  71 static int __init setup_noefi(char *arg)
  72 {
  73         disable_runtime = true;
  74         return 0;
  75 }
  76 early_param("noefi", setup_noefi);
  77
  78 bool efi_runtime_disabled(void)
  79 {
  80         return disable_runtime;
  81 }
  82
  83 static int __init parse_efi_cmdline(char *str)
  84 {
  85         if (!str) {
  86                 pr_warn("need at least one option\n");
  87                 return -EINVAL;
  88         }
  89
  90         if (parse_option_str(str, "debug"))
  91                 set_bit(EFI_DBG, &efi.flags);
  92
  93         if (parse_option_str(str, "noruntime"))
  94                 disable_runtime = true;
  95
  96         return 0;
  97 }
  98 early_param("efi", parse_efi_cmdline);
  99
 100 struct kobject *efi_kobj;
 101
 102 /*
 103  * Let's not leave out systab information that snuck into
 104  * the efivars driver
 105  * Note, do not add more fields in systab sysfs file as it breaks sysfs
 106  * one value per file rule!
 107  */
 108 static ssize_t systab_show(struct kobject *kobj,
 109                            struct kobj_attribute *attr, char *buf)
 110 {
 111         char *str = buf;
 112
 113         if (!kobj || !buf)
 114                 return -EINVAL;
 115
 116         if (efi.mps != EFI_INVALID_TABLE_ADDR)
 117                 str += sprintf(str, "MPS=0x%lx\n", efi.mps);
 118         if (efi.acpi20 != EFI_INVALID_TABLE_ADDR)
 119                 str += sprintf(str, "ACPI20=0x%lx\n", efi.acpi20);
 120         if (efi.acpi != EFI_INVALID_TABLE_ADDR)
 121                 str += sprintf(str, "ACPI=0x%lx\n", efi.acpi);
 122         /*
 123          * If both SMBIOS and SMBIOS3 entry points are implemented, the
 124          * SMBIOS3 entry point shall be preferred, so we list it first to
 125          * let applications stop parsing after the first match.
 126          */
 127         if (efi.smbios3 != EFI_INVALID_TABLE_ADDR)
 128                 str += sprintf(str, "SMBIOS3=0x%lx\n", efi.smbios3);
 129         if (efi.smbios != EFI_INVALID_TABLE_ADDR)
 130                 str += sprintf(str, "SMBIOS=0x%lx\n", efi.smbios);
 131         if (efi.hcdp != EFI_INVALID_TABLE_ADDR)
 132                 str += sprintf(str, "HCDP=0x%lx\n", efi.hcdp);
 133         if (efi.boot_info != EFI_INVALID_TABLE_ADDR)
 134                 str += sprintf(str, "BOOTINFO=0x%lx\n", efi.boot_info);
 135         if (efi.uga != EFI_INVALID_TABLE_ADDR)
 136                 str += sprintf(str, "UGA=0x%lx\n", efi.uga);
 137
 138         return str - buf;
 139 }
 140
 141 static struct kobj_attribute efi_attr_systab = __ATTR_RO_MODE(systab, 0400);
 142
 143 #define EFI_FIELD(var) efi.var
 144
 145 #define EFI_ATTR_SHOW(name) \
 146 static ssize_t name##_show(struct kobject *kobj, \
 147                                 struct kobj_attribute *attr, char *buf) \
 148 { \
 149         return sprintf(buf, "0x%lx\n", EFI_FIELD(name)); \
 150 }
 151
 152 EFI_ATTR_SHOW(fw_vendor);
 153 EFI_ATTR_SHOW(runtime);
 154 EFI_ATTR_SHOW(config_table);
 155
 156 static ssize_t fw_platform_size_show(struct kobject *kobj,
 157                                      struct kobj_attribute *attr, char *buf)
 158 {
 159         return sprintf(buf, "%d\n", efi_enabled(EFI_64BIT) ? 64 : 32);
 160 }
 161
 162 static struct kobj_attribute efi_attr_fw_vendor = __ATTR_RO(fw_vendor);
 163 static struct kobj_attribute efi_attr_runtime = __ATTR_RO(runtime);
 164 static struct kobj_attribute efi_attr_config_table = __ATTR_RO(config_table);
 165 static struct kobj_attribute efi_attr_fw_platform_size =
 166         __ATTR_RO(fw_platform_size);
 167
 168 static struct attribute *efi_subsys_attrs[] = {
 169         &efi_attr_systab.attr,
 170         &efi_attr_fw_vendor.attr,
 171         &efi_attr_runtime.attr,
 172         &efi_attr_config_table.attr,
 173         &efi_attr_fw_platform_size.attr,
 174         NULL,
 175 };
 176
 177 static umode_t efi_attr_is_visible(struct kobject *kobj,
 178                                    struct attribute *attr, int n)
 179 {
 180         if (attr == &efi_attr_fw_vendor.attr) {
 181                 if (efi_enabled(EFI_PARAVIRT) ||
 182                                 efi.fw_vendor == EFI_INVALID_TABLE_ADDR)
 183                         return 0;
 184         } else if (attr == &efi_attr_runtime.attr) {
 185                 if (efi.runtime == EFI_INVALID_TABLE_ADDR)
 186                         return 0;
 187         } else if (attr == &efi_attr_config_table.attr) {
 188                 if (efi.config_table == EFI_INVALID_TABLE_ADDR)
 189                         return 0;
 190         }
 191
 192         return attr->mode;
 193 }
 194
 195 static const struct attribute_group efi_subsys_attr_group = {
 196         .attrs = efi_subsys_attrs,
 197         .is_visible = efi_attr_is_visible,
 198 };
 199
 200 static struct efivars generic_efivars;
 201 static struct efivar_operations generic_ops;
 202
 203 static int generic_ops_register(void)
 204 {
 205         generic_ops.get_variable = efi.get_variable;
 206         generic_ops.set_variable = efi.set_variable;
 207         generic_ops.set_variable_nonblocking = efi.set_variable_nonblocking;
 208         generic_ops.get_next_variable = efi.get_next_variable;
 209         generic_ops.query_variable_store = efi_query_variable_store;
 210
 211         return efivars_register(&generic_efivars, &generic_ops, efi_kobj);
 212 }
 213
 214 static void generic_ops_unregister(void)
 215 {
 216         efivars_unregister(&generic_efivars);
 217 }
 218
 219 #if IS_ENABLED(CONFIG_ACPI)
 220 #define EFIVAR_SSDT_NAME_MAX    16
 221 static char efivar_ssdt[EFIVAR_SSDT_NAME_MAX] __initdata;
 222 static int __init efivar_ssdt_setup(char *str)
 223 {
 224         if (strlen(str) < sizeof(efivar_ssdt))
 225                 memcpy(efivar_ssdt, str, strlen(str));
 226         else
 227                 pr_warn("efivar_ssdt: name too long: %s\n", str);
 228         return 0;
 229 }
 230 __setup("efivar_ssdt=", efivar_ssdt_setup);
 231
 232 static __init int efivar_ssdt_iter(efi_char16_t *name, efi_guid_t vendor,
 233                                    unsigned long name_size, void *data)
 234 {
 235         struct efivar_entry *entry;
 236         struct list_head *list = data;
 237         char utf8_name[EFIVAR_SSDT_NAME_MAX];
 238         int limit = min_t(unsigned long, EFIVAR_SSDT_NAME_MAX, name_size);
 239
 240         ucs2_as_utf8(utf8_name, name, limit - 1);
 241         if (strncmp(utf8_name, efivar_ssdt, limit) != 0)
 242                 return 0;
 243
 244         entry = kmalloc(sizeof(*entry), GFP_KERNEL);
 245         if (!entry)
 246                 return 0;
 247
 248         memcpy(entry->var.VariableName, name, name_size);
 249         memcpy(&entry->var.VendorGuid, &vendor, sizeof(efi_guid_t));
 250
 251         efivar_entry_add(entry, list);
 252
 253         return 0;
 254 }
 255
 256 static __init int efivar_ssdt_load(void)
 257 {
 258         LIST_HEAD(entries);
 259         struct efivar_entry *entry, *aux;
 260         unsigned long size;
 261         void *data;
 262         int ret;
 263
 264         ret = efivar_init(efivar_ssdt_iter, &entries, true, &entries);
 265
 266         list_for_each_entry_safe(entry, aux, &entries, list) {
 267                 pr_info("loading SSDT from variable %s-%pUl\n", efivar_ssdt,
 268                         &entry->var.VendorGuid);
 269
 270                 list_del(&entry->list);
 271
 272                 ret = efivar_entry_size(entry, &size);
 273                 if (ret) {
 274                         pr_err("failed to get var size\n");
 275                         goto free_entry;
 276                 }
 277
 278                 data = kmalloc(size, GFP_KERNEL);
 279                 if (!data) {
 280                         ret = -ENOMEM;
 281                         goto free_entry;
 282                 }
 283
 284                 ret = efivar_entry_get(entry, NULL, &size, data);
 285                 if (ret) {
 286                         pr_err("failed to get var data\n");
 287                         goto free_data;
 288                 }
 289
 290                 ret = acpi_load_table(data);
 291                 if (ret) {
 292                         pr_err("failed to load table: %d\n", ret);
 293                         goto free_data;
 294                 }
 295
 296                 goto free_entry;
 297
 298 free_data:
 299                 kfree(data);
 300
 301 free_entry:
 302                 kfree(entry);
 303         }
 304
 305         return ret;
 306 }
 307 #else
 308 static inline int efivar_ssdt_load(void) { return 0; }
 309 #endif
 310
 311 /*
 312  * We register the efi subsystem with the firmware subsystem and the
 313  * efivars subsystem with the efi subsystem, if the system was booted with
 314  * EFI.
 315  */
 316 static int __init efisubsys_init(void)
 317 {
 318         int error;
 319
 320         if (!efi_enabled(EFI_BOOT))
 321                 return 0;
 322
 323         /*
 324          * Since we process only one efi_runtime_service() at a time, an
 325          * ordered workqueue (which creates only one execution context)
 326          * should suffice all our needs.
 327          */
 328         efi_rts_wq = alloc_ordered_workqueue("efi_rts_wq", 0);
 329         if (!efi_rts_wq) {
 330                 pr_err("Creating efi_rts_wq failed, EFI runtime services disabled.\n");
 331                 clear_bit(EFI_RUNTIME_SERVICES, &efi.flags);
 332                 return 0;
 333         }
 334
 335         /* We register the efi directory at /sys/firmware/efi */
 336         efi_kobj = kobject_create_and_add("efi", firmware_kobj);
 337         if (!efi_kobj) {
 338                 pr_err("efi: Firmware registration failed.\n");
 339                 return -ENOMEM;
 340         }
 341
 342         error = generic_ops_register();
 343         if (error)
 344                 goto err_put;
 345
 346         if (efi_enabled(EFI_RUNTIME_SERVICES))
 347                 efivar_ssdt_load();
 348
 349         error = sysfs_create_group(efi_kobj, &efi_subsys_attr_group);
 350         if (error) {
 351                 pr_err("efi: Sysfs attribute export failed with error %d.\n",
 352                        error);
 353                 goto err_unregister;
 354         }
 355
 356         error = efi_runtime_map_init(efi_kobj);
 357         if (error)
 358                 goto err_remove_group;
 359
 360         /* and the standard mountpoint for efivarfs */
 361         error = sysfs_create_mount_point(efi_kobj, "efivars");
 362         if (error) {
 363                 pr_err("efivars: Subsystem registration failed.\n");
 364                 goto err_remove_group;
 365         }
 366
 367         return 0;
 368
 369 err_remove_group:
 370         sysfs_remove_group(efi_kobj, &efi_subsys_attr_group);
 371 err_unregister:
 372         generic_ops_unregister();
 373 err_put:
 374         kobject_put(efi_kobj);
 375         return error;
 376 }
 377
 378 subsys_initcall(efisubsys_init);
 379
 380 /*
 381  * Find the efi memory descriptor for a given physical address.  Given a
 382  * physical address, determine if it exists within an EFI Memory Map entry,
 383  * and if so, populate the supplied memory descriptor with the appropriate
 384  * data.
 385  */
 386 int efi_mem_desc_lookup(u64 phys_addr, efi_memory_desc_t *out_md)
 387 {
 388         efi_memory_desc_t *md;
 389
 390         if (!efi_enabled(EFI_MEMMAP)) {
 391                 pr_err_once("EFI_MEMMAP is not enabled.\n");
 392                 return -EINVAL;
 393         }
 394
 395         if (!out_md) {
 396                 pr_err_once("out_md is null.\n");
 397                 return -EINVAL;
 398         }
 399
 400         for_each_efi_memory_desc(md) {
 401                 u64 size;
 402                 u64 end;
 403
 404                 size = md->num_pages << EFI_PAGE_SHIFT;
 405                 end = md->phys_addr + size;
 406                 if (phys_addr >= md->phys_addr && phys_addr < end) {
 407                         memcpy(out_md, md, sizeof(*out_md));
 408                         return 0;
 409                 }
 410         }
 411         return -ENOENT;
 412 }
 413
 414 /*
 415  * Calculate the highest address of an efi memory descriptor.
 416  */
 417 u64 __init efi_mem_desc_end(efi_memory_desc_t *md)
 418 {
 419         u64 size = md->num_pages << EFI_PAGE_SHIFT;
 420         u64 end = md->phys_addr + size;
 421         return end;
 422 }
 423
 424 void __init __weak efi_arch_mem_reserve(phys_addr_t addr, u64 size) {}
 425
 426 /**
 427  * efi_mem_reserve - Reserve an EFI memory region
 428  * @addr: Physical address to reserve
 429  * @size: Size of reservation
 430  *
 431  * Mark a region as reserved from general kernel allocation and
 432  * prevent it being released by efi_free_boot_services().
 433  *
 434  * This function should be called drivers once they've parsed EFI
 435  * configuration tables to figure out where their data lives, e.g.
 436  * efi_esrt_init().
 437  */
 438 void __init efi_mem_reserve(phys_addr_t addr, u64 size)
 439 {
 440         if (!memblock_is_region_reserved(addr, size))
 441                 memblock_reserve(addr, size);
 442
 443         /*
 444          * Some architectures (x86) reserve all boot services ranges
 445          * until efi_free_boot_services() because of buggy firmware
 446          * implementations. This means the above memblock_reserve() is
 447          * superfluous on x86 and instead what it needs to do is
 448          * ensure the @start, @size is not freed.
 449          */
 450         efi_arch_mem_reserve(addr, size);
 451 }
 452
 453 static __initdata efi_config_table_type_t common_tables[] = {
 454         {ACPI_20_TABLE_GUID, "ACPI 2.0", &efi.acpi20},
 455         {ACPI_TABLE_GUID, "ACPI", &efi.acpi},
 456         {HCDP_TABLE_GUID, "HCDP", &efi.hcdp},
 457         {MPS_TABLE_GUID, "MPS", &efi.mps},
 458         {SMBIOS_TABLE_GUID, "SMBIOS", &efi.smbios},
 459         {SMBIOS3_TABLE_GUID, "SMBIOS 3.0", &efi.smbios3},
 460         {UGA_IO_PROTOCOL_GUID, "UGA", &efi.uga},
 461         {EFI_SYSTEM_RESOURCE_TABLE_GUID, "ESRT", &efi.esrt},
 462         {EFI_PROPERTIES_TABLE_GUID, "PROP", &efi.properties_table},
 463         {EFI_MEMORY_ATTRIBUTES_TABLE_GUID, "MEMATTR", &efi.mem_attr_table},
 464         {LINUX_EFI_RANDOM_SEED_TABLE_GUID, "RNG", &efi.rng_seed},
 465         {LINUX_EFI_TPM_EVENT_LOG_GUID, "TPMEventLog", &efi.tpm_log},
 466         {LINUX_EFI_TPM_FINAL_LOG_GUID, "TPMFinalLog", &efi.tpm_final_log},
 467         {LINUX_EFI_MEMRESERVE_TABLE_GUID, "MEMRESERVE", &efi.mem_reserve},
 468 #ifdef CONFIG_EFI_RCI2_TABLE
 469         {DELLEMC_EFI_RCI2_TABLE_GUID, NULL, &rci2_table_phys},
 470 #endif
 471         {NULL_GUID, NULL, NULL},
 472 };
 473
 474 static __init int match_config_table(efi_guid_t *guid,
 475                                      unsigned long table,
 476                                      efi_config_table_type_t *table_types)
 477 {
 478         int i;
 479
 480         if (table_types) {
 481                 for (i = 0; efi_guidcmp(table_types[i].guid, NULL_GUID); i++) {
 482                         if (!efi_guidcmp(*guid, table_types[i].guid)) {
 483                                 *(table_types[i].ptr) = table;
 484                                 if (table_types[i].name)
 485                                         pr_cont(" %s=0x%lx ",
 486                                                 table_types[i].name, table);
 487                                 return 1;
 488                         }
 489                 }
 490         }
 491
 492         return 0;
 493 }
 494
 495 int __init efi_config_parse_tables(void *config_tables, int count, int sz,
 496                                    efi_config_table_type_t *arch_tables)
 497 {
 498         void *tablep;
 499         int i;
 500
 501         tablep = config_tables;
 502         pr_info("");
 503         for (i = 0; i < count; i++) {
 504                 efi_guid_t guid;
 505                 unsigned long table;
 506
 507                 if (efi_enabled(EFI_64BIT)) {
 508                         u64 table64;
 509                         guid = ((efi_config_table_64_t *)tablep)->guid;
 510                         table64 = ((efi_config_table_64_t *)tablep)->table;
 511                         table = table64;
 512 #ifndef CONFIG_64BIT
 513                         if (table64 >> 32) {
 514                                 pr_cont("\n");
 515                                 pr_err("Table located above 4GB, disabling EFI.\n");
 516                                 return -EINVAL;
 517                         }
 518 #endif
 519                 } else {
 520                         guid = ((efi_config_table_32_t *)tablep)->guid;
 521                         table = ((efi_config_table_32_t *)tablep)->table;
 522                 }
 523
 524                 if (!match_config_table(&guid, table, common_tables))
 525                         match_config_table(&guid, table, arch_tables);
 526
 527                 tablep += sz;
 528         }
 529         pr_cont("\n");
 530         set_bit(EFI_CONFIG_TABLES, &efi.flags);
 531
 532         if (efi.rng_seed != EFI_INVALID_TABLE_ADDR) {
 533                 struct linux_efi_random_seed *seed;
 534                 u32 size = 0;
 535
 536                 seed = early_memremap(efi.rng_seed, sizeof(*seed));
 537                 if (seed != NULL) {
 538                         size = seed->size;
 539                         early_memunmap(seed, sizeof(*seed));
 540                 } else {
 541                         pr_err("Could not map UEFI random seed!\n");
 542                 }
 543                 if (size > 0) {
 544                         seed = early_memremap(efi.rng_seed,
 545                                               sizeof(*seed) + size);
 546                         if (seed != NULL) {
 547                                 pr_notice("seeding entropy pool\n");
 548                                 add_device_randomness(seed->bits, seed->size);
 549                                 early_memunmap(seed, sizeof(*seed) + size);
 550                         } else {
 551                                 pr_err("Could not map UEFI random seed!\n");
 552                         }
 553                 }
 554         }
 555
 556         if (efi_enabled(EFI_MEMMAP))
 557                 efi_memattr_init();
 558
 559         efi_tpm_eventlog_init();
 560
 561         /* Parse the EFI Properties table if it exists */
 562         if (efi.properties_table != EFI_INVALID_TABLE_ADDR) {
 563                 efi_properties_table_t *tbl;
 564
 565                 tbl = early_memremap(efi.properties_table, sizeof(*tbl));
 566                 if (tbl == NULL) {
 567                         pr_err("Could not map Properties table!\n");
 568                         return -ENOMEM;
 569                 }
 570
 571                 if (tbl->memory_protection_attribute &
 572                     EFI_PROPERTIES_RUNTIME_MEMORY_PROTECTION_NON_EXECUTABLE_PE_DATA)
 573                         set_bit(EFI_NX_PE_DATA, &efi.flags);
 574
 575                 early_memunmap(tbl, sizeof(*tbl));
 576         }
 577
 578         if (efi.mem_reserve != EFI_INVALID_TABLE_ADDR) {
 579                 unsigned long prsv = efi.mem_reserve;
 580
 581                 while (prsv) {
 582                         struct linux_efi_memreserve *rsv;
 583                         u8 *p;
 584                         int i;
 585
 586                         /*
 587                          * Just map a full page: that is what we will get
 588                          * anyway, and it permits us to map the entire entry
 589                          * before knowing its size.
 590                          */
 591                         p = early_memremap(ALIGN_DOWN(prsv, PAGE_SIZE),
 592                                            PAGE_SIZE);
 593                         if (p == NULL) {
 594                                 pr_err("Could not map UEFI memreserve entry!\n");
 595                                 return -ENOMEM;
 596                         }
 597
 598                         rsv = (void *)(p + prsv % PAGE_SIZE);
 599
 600                         /* reserve the entry itself */
 601                         memblock_reserve(prsv, EFI_MEMRESERVE_SIZE(rsv->size));
 602
 603                         for (i = 0; i < atomic_read(&rsv->count); i++) {
 604                                 memblock_reserve(rsv->entry[i].base,
 605                                                  rsv->entry[i].size);
 606                         }
 607
 608                         prsv = rsv->next;
 609                         early_memunmap(p, PAGE_SIZE);
 610                 }
 611         }
 612
 613         return 0;
 614 }
 615
 616 int __init efi_config_init(efi_config_table_type_t *arch_tables)
 617 {
 618         void *config_tables;
 619         int sz, ret;
 620
 621         if (efi.systab->nr_tables == 0)
 622                 return 0;
 623
 624         if (efi_enabled(EFI_64BIT))
 625                 sz = sizeof(efi_config_table_64_t);
 626         else
 627                 sz = sizeof(efi_config_table_32_t);
 628
 629         /*
 630          * Let's see what config tables the firmware passed to us.
 631          */
 632         config_tables = early_memremap(efi.systab->tables,
 633                                        efi.systab->nr_tables * sz);
 634         if (config_tables == NULL) {
 635                 pr_err("Could not map Configuration table!\n");
 636                 return -ENOMEM;
 637         }
 638
 639         ret = efi_config_parse_tables(config_tables, efi.systab->nr_tables, sz,
 640                                       arch_tables);
 641
 642         early_memunmap(config_tables, efi.systab->nr_tables * sz);
 643         return ret;
 644 }
 645
 646 #ifdef CONFIG_EFI_VARS_MODULE
 647 static int __init efi_load_efivars(void)
 648 {
 649         struct platform_device *pdev;
 650
 651         if (!efi_enabled(EFI_RUNTIME_SERVICES))
 652                 return 0;
 653
 654         pdev = platform_device_register_simple("efivars", 0, NULL, 0);
 655         return PTR_ERR_OR_ZERO(pdev);
 656 }
 657 device_initcall(efi_load_efivars);
 658 #endif
 659
 660 #ifdef CONFIG_EFI_PARAMS_FROM_FDT
 661
 662 #define UEFI_PARAM(name, prop, field)                      \
 663         {                                                  \
 664                 { name },                                  \
 665                 { prop },                                  \
 666                 offsetof(struct efi_fdt_params, field),    \
 667                 FIELD_SIZEOF(struct efi_fdt_params, field) \
 668         }
 669
 670 struct params {
 671         const char name[32];
 672         const char propname[32];
 673         int offset;
 674         int size;
 675 };
 676
 677 static __initdata struct params fdt_params[] = {
 678         UEFI_PARAM("System Table", "linux,uefi-system-table", system_table),
 679         UEFI_PARAM("MemMap Address", "linux,uefi-mmap-start", mmap),
 680         UEFI_PARAM("MemMap Size", "linux,uefi-mmap-size", mmap_size),
 681         UEFI_PARAM("MemMap Desc. Size", "linux,uefi-mmap-desc-size", desc_size),
 682         UEFI_PARAM("MemMap Desc. Version", "linux,uefi-mmap-desc-ver", desc_ver)
 683 };
 684
 685 static __initdata struct params xen_fdt_params[] = {
 686         UEFI_PARAM("System Table", "xen,uefi-system-table", system_table),
 687         UEFI_PARAM("MemMap Address", "xen,uefi-mmap-start", mmap),
 688         UEFI_PARAM("MemMap Size", "xen,uefi-mmap-size", mmap_size),
 689         UEFI_PARAM("MemMap Desc. Size", "xen,uefi-mmap-desc-size", desc_size),
 690         UEFI_PARAM("MemMap Desc. Version", "xen,uefi-mmap-desc-ver", desc_ver)
 691 };
 692
 693 #define EFI_FDT_PARAMS_SIZE     ARRAY_SIZE(fdt_params)
 694
 695 static __initdata struct {
 696         const char *uname;
 697         const char *subnode;
 698         struct params *params;
 699 } dt_params[] = {
 700         { "hypervisor", "uefi", xen_fdt_params },
 701         { "chosen", NULL, fdt_params },
 702 };
 703
 704 struct param_info {
 705         int found;
 706         void *params;
 707         const char *missing;
 708 };
 709
 710 static int __init __find_uefi_params(unsigned long node,
 711                                      struct param_info *info,
 712                                      struct params *params)
 713 {
 714         const void *prop;
 715         void *dest;
 716         u64 val;
 717         int i, len;
 718
 719         for (i = 0; i < EFI_FDT_PARAMS_SIZE; i++) {
 720                 prop = of_get_flat_dt_prop(node, params[i].propname, &len);
 721                 if (!prop) {
 722                         info->missing = params[i].name;
 723                         return 0;
 724                 }
 725
 726                 dest = info->params + params[i].offset;
 727                 info->found++;
 728
 729                 val = of_read_number(prop, len / sizeof(u32));
 730
 731                 if (params[i].size == sizeof(u32))
 732                         *(u32 *)dest = val;
 733                 else
 734                         *(u64 *)dest = val;
 735
 736                 if (efi_enabled(EFI_DBG))
 737                         pr_info("  %s: 0x%0*llx\n", params[i].name,
 738                                 params[i].size * 2, val);
 739         }
 740
 741         return 1;
 742 }
 743
 744 static int __init fdt_find_uefi_params(unsigned long node, const char *uname,
 745                                        int depth, void *data)
 746 {
 747         struct param_info *info = data;
 748         int i;
 749
 750         for (i = 0; i < ARRAY_SIZE(dt_params); i++) {
 751                 const char *subnode = dt_params[i].subnode;
 752
 753                 if (depth != 1 || strcmp(uname, dt_params[i].uname) != 0) {
 754                         info->missing = dt_params[i].params[0].name;
 755                         continue;
 756                 }
 757
 758                 if (subnode) {
 759                         int err = of_get_flat_dt_subnode_by_name(node, subnode);
 760
 761                         if (err < 0)
 762                                 return 0;
 763
 764                         node = err;
 765                 }
 766
 767                 return __find_uefi_params(node, info, dt_params[i].params);
 768         }
 769
 770         return 0;
 771 }
 772
 773 int __init efi_get_fdt_params(struct efi_fdt_params *params)
 774 {
 775         struct param_info info;
 776         int ret;
 777
 778         pr_info("Getting EFI parameters from FDT:\n");
 779
 780         info.found = 0;
 781         info.params = params;
 782
 783         ret = of_scan_flat_dt(fdt_find_uefi_params, &info);
 784         if (!info.found)
 785                 pr_info("UEFI not found.\n");
 786         else if (!ret)
 787                 pr_err("Can't find '%s' in device tree!\n",
 788                        info.missing);
 789
 790         return ret;
 791 }
 792 #endif /* CONFIG_EFI_PARAMS_FROM_FDT */
 793
 794 static __initdata char memory_type_name[][20] = {
 795         "Reserved",
 796         "Loader Code",
 797         "Loader Data",
 798         "Boot Code",
 799         "Boot Data",
 800         "Runtime Code",
 801         "Runtime Data",
 802         "Conventional Memory",
 803         "Unusable Memory",
 804         "ACPI Reclaim Memory",
 805         "ACPI Memory NVS",
 806         "Memory Mapped I/O",
 807         "MMIO Port Space",
 808         "PAL Code",
 809         "Persistent Memory",
 810 };
 811
 812 char * __init efi_md_typeattr_format(char *buf, size_t size,
 813                                      const efi_memory_desc_t *md)
 814 {
 815         char *pos;
 816         int type_len;
 817         u64 attr;
 818
 819         pos = buf;
 820         if (md->type >= ARRAY_SIZE(memory_type_name))
 821                 type_len = snprintf(pos, size, "[type=%u", md->type);
 822         else
 823                 type_len = snprintf(pos, size, "[%-*s",
 824                                     (int)(sizeof(memory_type_name[0]) - 1),
 825                                     memory_type_name[md->type]);
 826         if (type_len >= size)
 827                 return buf;
 828
 829         pos += type_len;
 830         size -= type_len;
 831
 832         attr = md->attribute;
 833         if (attr & ~(EFI_MEMORY_UC | EFI_MEMORY_WC | EFI_MEMORY_WT |
 834                      EFI_MEMORY_WB | EFI_MEMORY_UCE | EFI_MEMORY_RO |
 835                      EFI_MEMORY_WP | EFI_MEMORY_RP | EFI_MEMORY_XP |
 836                      EFI_MEMORY_NV |
 837                      EFI_MEMORY_RUNTIME | EFI_MEMORY_MORE_RELIABLE))
 838                 snprintf(pos, size, "|attr=0x%016llx]",
 839                          (unsigned long long)attr);
 840         else
 841                 snprintf(pos, size,
 842                          "|%3s|%2s|%2s|%2s|%2s|%2s|%2s|%3s|%2s|%2s|%2s|%2s]",
 843                          attr & EFI_MEMORY_RUNTIME ? "RUN" : "",
 844                          attr & EFI_MEMORY_MORE_RELIABLE ? "MR" : "",
 845                          attr & EFI_MEMORY_NV      ? "NV"  : "",
 846                          attr & EFI_MEMORY_XP      ? "XP"  : "",
 847                          attr & EFI_MEMORY_RP      ? "RP"  : "",
 848                          attr & EFI_MEMORY_WP      ? "WP"  : "",
 849                          attr & EFI_MEMORY_RO      ? "RO"  : "",
 850                          attr & EFI_MEMORY_UCE     ? "UCE" : "",
 851                          attr & EFI_MEMORY_WB      ? "WB"  : "",
 852                          attr & EFI_MEMORY_WT      ? "WT"  : "",
 853                          attr & EFI_MEMORY_WC      ? "WC"  : "",
 854                          attr & EFI_MEMORY_UC      ? "UC"  : "");
 855         return buf;
 856 }
 857
 858 /*
 859  * IA64 has a funky EFI memory map that doesn't work the same way as
 860  * other architectures.
 861  */
 862 #ifndef CONFIG_IA64
 863 /*
 864  * efi_mem_attributes - lookup memmap attributes for physical address
 865  * @phys_addr: the physical address to lookup
 866  *
 867  * Search in the EFI memory map for the region covering
 868  * @phys_addr. Returns the EFI memory attributes if the region
 869  * was found in the memory map, 0 otherwise.
 870  */
 871 u64 efi_mem_attributes(unsigned long phys_addr)
 872 {
 873         efi_memory_desc_t *md;
 874
 875         if (!efi_enabled(EFI_MEMMAP))
 876                 return 0;
 877
 878         for_each_efi_memory_desc(md) {
 879                 if ((md->phys_addr <= phys_addr) &&
 880                     (phys_addr < (md->phys_addr +
 881                     (md->num_pages << EFI_PAGE_SHIFT))))
 882                         return md->attribute;
 883         }
 884         return 0;
 885 }
 886
 887 /*
 888  * efi_mem_type - lookup memmap type for physical address
 889  * @phys_addr: the physical address to lookup
 890  *
 891  * Search in the EFI memory map for the region covering @phys_addr.
 892  * Returns the EFI memory type if the region was found in the memory
 893  * map, EFI_RESERVED_TYPE (zero) otherwise.
 894  */
 895 int efi_mem_type(unsigned long phys_addr)
 896 {
 897         const efi_memory_desc_t *md;
 898
 899         if (!efi_enabled(EFI_MEMMAP))
 900                 return -ENOTSUPP;
 901
 902         for_each_efi_memory_desc(md) {
 903                 if ((md->phys_addr <= phys_addr) &&
 904                     (phys_addr < (md->phys_addr +
 905                                   (md->num_pages << EFI_PAGE_SHIFT))))
 906                         return md->type;
 907         }
 908         return -EINVAL;
 909 }
 910 #endif
 911
 912 int efi_status_to_err(efi_status_t status)
 913 {
 914         int err;
 915
 916         switch (status) {
 917         case EFI_SUCCESS:
 918                 err = 0;
 919                 break;
 920         case EFI_INVALID_PARAMETER:
 921                 err = -EINVAL;
 922                 break;
 923         case EFI_OUT_OF_RESOURCES:
 924                 err = -ENOSPC;
 925                 break;
 926         case EFI_DEVICE_ERROR:
 927                 err = -EIO;
 928                 break;
 929         case EFI_WRITE_PROTECTED:
 930                 err = -EROFS;
 931                 break;
 932         case EFI_SECURITY_VIOLATION:
 933                 err = -EACCES;
 934                 break;
 935         case EFI_NOT_FOUND:
 936                 err = -ENOENT;
 937                 break;
 938         case EFI_ABORTED:
 939                 err = -EINTR;
 940                 break;
 941         default:
 942                 err = -EINVAL;
 943         }
 944
 945         return err;
 946 }
 947
 948 static DEFINE_SPINLOCK(efi_mem_reserve_persistent_lock);
 949 static struct linux_efi_memreserve *efi_memreserve_root __ro_after_init;
 950
 951 static int __init efi_memreserve_map_root(void)
 952 {
 953         if (efi.mem_reserve == EFI_INVALID_TABLE_ADDR)
 954                 return -ENODEV;
 955
 956         efi_memreserve_root = memremap(efi.mem_reserve,
 957                                        sizeof(*efi_memreserve_root),
 958                                        MEMREMAP_WB);
 959         if (WARN_ON_ONCE(!efi_memreserve_root))
 960                 return -ENOMEM;
 961         return 0;
 962 }
 963
 964 int __ref efi_mem_reserve_persistent(phys_addr_t addr, u64 size)
 965 {
 966         struct linux_efi_memreserve *rsv;
 967         unsigned long prsv;
 968         int rc, index;
 969
 970         if (efi_memreserve_root == (void *)ULONG_MAX)
 971                 return -ENODEV;
 972
 973         if (!efi_memreserve_root) {
 974                 rc = efi_memreserve_map_root();
 975                 if (rc)
 976                         return rc;
 977         }
 978
 979         /* first try to find a slot in an existing linked list entry */
 980         for (prsv = efi_memreserve_root->next; prsv; prsv = rsv->next) {
 981                 rsv = memremap(prsv, sizeof(*rsv), MEMREMAP_WB);
 982                 index = atomic_fetch_add_unless(&rsv->count, 1, rsv->size);
 983                 if (index < rsv->size) {
 984                         rsv->entry[index].base = addr;
 985                         rsv->entry[index].size = size;
 986
 987                         memunmap(rsv);
 988                         return 0;
 989                 }
 990                 memunmap(rsv);
 991         }
 992
 993         /* no slot found - allocate a new linked list entry */
 994         rsv = (struct linux_efi_memreserve *)__get_free_page(GFP_ATOMIC);
 995         if (!rsv)
 996                 return -ENOMEM;
 997
 998         /*
 999          * The memremap() call above assumes that a linux_efi_memreserve entry
1000          * never crosses a page boundary, so let's ensure that this remains true
1001          * even when kexec'ing a 4k pages kernel from a >4k pages kernel, by
1002          * using SZ_4K explicitly in the size calculation below.
1003          */
1004         rsv->size = EFI_MEMRESERVE_COUNT(SZ_4K);
1005         atomic_set(&rsv->count, 1);
1006         rsv->entry[0].base = addr;
1007         rsv->entry[0].size = size;
1008
1009         spin_lock(&efi_mem_reserve_persistent_lock);
1010         rsv->next = efi_memreserve_root->next;
1011         efi_memreserve_root->next = __pa(rsv);
1012         spin_unlock(&efi_mem_reserve_persistent_lock);
1013
1014         return 0;
1015 }
1016
1017 static int __init efi_memreserve_root_init(void)
1018 {
1019         if (efi_memreserve_root)
1020                 return 0;
1021         if (efi_memreserve_map_root())
1022                 efi_memreserve_root = (void *)ULONG_MAX;
1023         return 0;
1024 }
1025 early_initcall(efi_memreserve_root_init);
1026
1027 #ifdef CONFIG_KEXEC
1028 static int update_efi_random_seed(struct notifier_block *nb,
1029                                   unsigned long code, void *unused)
1030 {
1031         struct linux_efi_random_seed *seed;
1032         u32 size = 0;
1033
1034         if (!kexec_in_progress)
1035                 return NOTIFY_DONE;
1036
1037         seed = memremap(efi.rng_seed, sizeof(*seed), MEMREMAP_WB);
1038         if (seed != NULL) {
1039                 size = min(seed->size, EFI_RANDOM_SEED_SIZE);
1040                 memunmap(seed);
1041         } else {
1042                 pr_err("Could not map UEFI random seed!\n");
1043         }
1044         if (size > 0) {
1045                 seed = memremap(efi.rng_seed, sizeof(*seed) + size,
1046                                 MEMREMAP_WB);
1047                 if (seed != NULL) {
1048                         seed->size = size;
1049                         get_random_bytes(seed->bits, seed->size);
1050                         memunmap(seed);
1051                 } else {
1052                         pr_err("Could not map UEFI random seed!\n");
1053                 }
1054         }
1055         return NOTIFY_DONE;
1056 }
1057
1058 static struct notifier_block efi_random_seed_nb = {
1059         .notifier_call = update_efi_random_seed,
1060 };
1061
1062 static int register_update_efi_random_seed(void)
1063 {
1064         if (efi.rng_seed == EFI_INVALID_TABLE_ADDR)
1065                 return 0;
1066         return register_reboot_notifier(&efi_random_seed_nb);
1067 }
1068 late_initcall(register_update_efi_random_seed);
1069 #endif