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