drivers/firmware/efi/efi.c

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