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