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 0;
 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                 destroy_workqueue(efi_rts_wq);
 363                 return -ENOMEM;
 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         destroy_workqueue(efi_rts_wq);
 400         return error;
 401 }
 402
 403 subsys_initcall(efisubsys_init);
 404
 405 /*
 406  * Find the efi memory descriptor for a given physical address.  Given a
 407  * physical address, determine if it exists within an EFI Memory Map entry,
 408  * and if so, populate the supplied memory descriptor with the appropriate
 409  * data.
 410  */
 411 int efi_mem_desc_lookup(u64 phys_addr, efi_memory_desc_t *out_md)
 412 {
 413         efi_memory_desc_t *md;
 414
 415         if (!efi_enabled(EFI_MEMMAP)) {
 416                 pr_err_once("EFI_MEMMAP is not enabled.\n");
 417                 return -EINVAL;
 418         }
 419
 420         if (!out_md) {
 421                 pr_err_once("out_md is null.\n");
 422                 return -EINVAL;
 423         }
 424
 425         for_each_efi_memory_desc(md) {
 426                 u64 size;
 427                 u64 end;
 428
 429                 size = md->num_pages << EFI_PAGE_SHIFT;
 430                 end = md->phys_addr + size;
 431                 if (phys_addr >= md->phys_addr && phys_addr < end) {
 432                         memcpy(out_md, md, sizeof(*out_md));
 433                         return 0;
 434                 }
 435         }
 436         return -ENOENT;
 437 }
 438
 439 /*
 440  * Calculate the highest address of an efi memory descriptor.
 441  */
 442 u64 __init efi_mem_desc_end(efi_memory_desc_t *md)
 443 {
 444         u64 size = md->num_pages << EFI_PAGE_SHIFT;
 445         u64 end = md->phys_addr + size;
 446         return end;
 447 }
 448
 449 void __init __weak efi_arch_mem_reserve(phys_addr_t addr, u64 size) {}
 450
 451 /**
 452  * efi_mem_reserve - Reserve an EFI memory region
 453  * @addr: Physical address to reserve
 454  * @size: Size of reservation
 455  *
 456  * Mark a region as reserved from general kernel allocation and
 457  * prevent it being released by efi_free_boot_services().
 458  *
 459  * This function should be called drivers once they've parsed EFI
 460  * configuration tables to figure out where their data lives, e.g.
 461  * efi_esrt_init().
 462  */
 463 void __init efi_mem_reserve(phys_addr_t addr, u64 size)
 464 {
 465         if (!memblock_is_region_reserved(addr, size))
 466                 memblock_reserve(addr, size);
 467
 468         /*
 469          * Some architectures (x86) reserve all boot services ranges
 470          * until efi_free_boot_services() because of buggy firmware
 471          * implementations. This means the above memblock_reserve() is
 472          * superfluous on x86 and instead what it needs to do is
 473          * ensure the @start, @size is not freed.
 474          */
 475         efi_arch_mem_reserve(addr, size);
 476 }
 477
 478 static __initdata efi_config_table_type_t common_tables[] = {
 479         {ACPI_20_TABLE_GUID, "ACPI 2.0", &efi.acpi20},
 480         {ACPI_TABLE_GUID, "ACPI", &efi.acpi},
 481         {HCDP_TABLE_GUID, "HCDP", &efi.hcdp},
 482         {MPS_TABLE_GUID, "MPS", &efi.mps},
 483         {SAL_SYSTEM_TABLE_GUID, "SALsystab", &efi.sal_systab},
 484         {SMBIOS_TABLE_GUID, "SMBIOS", &efi.smbios},
 485         {SMBIOS3_TABLE_GUID, "SMBIOS 3.0", &efi.smbios3},
 486         {UGA_IO_PROTOCOL_GUID, "UGA", &efi.uga},
 487         {EFI_SYSTEM_RESOURCE_TABLE_GUID, "ESRT", &efi.esrt},
 488         {EFI_PROPERTIES_TABLE_GUID, "PROP", &efi.properties_table},
 489         {EFI_MEMORY_ATTRIBUTES_TABLE_GUID, "MEMATTR", &efi.mem_attr_table},
 490         {LINUX_EFI_RANDOM_SEED_TABLE_GUID, "RNG", &efi.rng_seed},
 491         {LINUX_EFI_TPM_EVENT_LOG_GUID, "TPMEventLog", &efi.tpm_log},
 492         {NULL_GUID, NULL, NULL},
 493 };
 494
 495 static __init int match_config_table(efi_guid_t *guid,
 496                                      unsigned long table,
 497                                      efi_config_table_type_t *table_types)
 498 {
 499         int i;
 500
 501         if (table_types) {
 502                 for (i = 0; efi_guidcmp(table_types[i].guid, NULL_GUID); i++) {
 503                         if (!efi_guidcmp(*guid, table_types[i].guid)) {
 504                                 *(table_types[i].ptr) = table;
 505                                 if (table_types[i].name)
 506                                         pr_cont(" %s=0x%lx ",
 507                                                 table_types[i].name, table);
 508                                 return 1;
 509                         }
 510                 }
 511         }
 512
 513         return 0;
 514 }
 515
 516 int __init efi_config_parse_tables(void *config_tables, int count, int sz,
 517                                    efi_config_table_type_t *arch_tables)
 518 {
 519         void *tablep;
 520         int i;
 521
 522         tablep = config_tables;
 523         pr_info("");
 524         for (i = 0; i < count; i++) {
 525                 efi_guid_t guid;
 526                 unsigned long table;
 527
 528                 if (efi_enabled(EFI_64BIT)) {
 529                         u64 table64;
 530                         guid = ((efi_config_table_64_t *)tablep)->guid;
 531                         table64 = ((efi_config_table_64_t *)tablep)->table;
 532                         table = table64;
 533 #ifndef CONFIG_64BIT
 534                         if (table64 >> 32) {
 535                                 pr_cont("\n");
 536                                 pr_err("Table located above 4GB, disabling EFI.\n");
 537                                 return -EINVAL;
 538                         }
 539 #endif
 540                 } else {
 541                         guid = ((efi_config_table_32_t *)tablep)->guid;
 542                         table = ((efi_config_table_32_t *)tablep)->table;
 543                 }
 544
 545                 if (!match_config_table(&guid, table, common_tables))
 546                         match_config_table(&guid, table, arch_tables);
 547
 548                 tablep += sz;
 549         }
 550         pr_cont("\n");
 551         set_bit(EFI_CONFIG_TABLES, &efi.flags);
 552
 553         if (efi.rng_seed != EFI_INVALID_TABLE_ADDR) {
 554                 struct linux_efi_random_seed *seed;
 555                 u32 size = 0;
 556
 557                 seed = early_memremap(efi.rng_seed, sizeof(*seed));
 558                 if (seed != NULL) {
 559                         size = seed->size;
 560                         early_memunmap(seed, sizeof(*seed));
 561                 } else {
 562                         pr_err("Could not map UEFI random seed!\n");
 563                 }
 564                 if (size > 0) {
 565                         seed = early_memremap(efi.rng_seed,
 566                                               sizeof(*seed) + size);
 567                         if (seed != NULL) {
 568                                 pr_notice("seeding entropy pool\n");
 569                                 add_device_randomness(seed->bits, seed->size);
 570                                 early_memunmap(seed, sizeof(*seed) + size);
 571                         } else {
 572                                 pr_err("Could not map UEFI random seed!\n");
 573                         }
 574                 }
 575         }
 576
 577         if (!IS_ENABLED(CONFIG_X86_32) && efi_enabled(EFI_MEMMAP))
 578                 efi_memattr_init();
 579
 580         efi_tpm_eventlog_init();
 581
 582         /* Parse the EFI Properties table if it exists */
 583         if (efi.properties_table != EFI_INVALID_TABLE_ADDR) {
 584                 efi_properties_table_t *tbl;
 585
 586                 tbl = early_memremap(efi.properties_table, sizeof(*tbl));
 587                 if (tbl == NULL) {
 588                         pr_err("Could not map Properties table!\n");
 589                         return -ENOMEM;
 590                 }
 591
 592                 if (tbl->memory_protection_attribute &
 593                     EFI_PROPERTIES_RUNTIME_MEMORY_PROTECTION_NON_EXECUTABLE_PE_DATA)
 594                         set_bit(EFI_NX_PE_DATA, &efi.flags);
 595
 596                 early_memunmap(tbl, sizeof(*tbl));
 597         }
 598
 599         return 0;
 600 }
 601
 602 int __init efi_config_init(efi_config_table_type_t *arch_tables)
 603 {
 604         void *config_tables;
 605         int sz, ret;
 606
 607         if (efi_enabled(EFI_64BIT))
 608                 sz = sizeof(efi_config_table_64_t);
 609         else
 610                 sz = sizeof(efi_config_table_32_t);
 611
 612         /*
 613          * Let's see what config tables the firmware passed to us.
 614          */
 615         config_tables = early_memremap(efi.systab->tables,
 616                                        efi.systab->nr_tables * sz);
 617         if (config_tables == NULL) {
 618                 pr_err("Could not map Configuration table!\n");
 619                 return -ENOMEM;
 620         }
 621
 622         ret = efi_config_parse_tables(config_tables, efi.systab->nr_tables, sz,
 623                                       arch_tables);
 624
 625         early_memunmap(config_tables, efi.systab->nr_tables * sz);
 626         return ret;
 627 }
 628
 629 #ifdef CONFIG_EFI_VARS_MODULE
 630 static int __init efi_load_efivars(void)
 631 {
 632         struct platform_device *pdev;
 633
 634         if (!efi_enabled(EFI_RUNTIME_SERVICES))
 635                 return 0;
 636
 637         pdev = platform_device_register_simple("efivars", 0, NULL, 0);
 638         return PTR_ERR_OR_ZERO(pdev);
 639 }
 640 device_initcall(efi_load_efivars);
 641 #endif
 642
 643 #ifdef CONFIG_EFI_PARAMS_FROM_FDT
 644
 645 #define UEFI_PARAM(name, prop, field)                      \
 646         {                                                  \
 647                 { name },                                  \
 648                 { prop },                                  \
 649                 offsetof(struct efi_fdt_params, field),    \
 650                 FIELD_SIZEOF(struct efi_fdt_params, field) \
 651         }
 652
 653 struct params {
 654         const char name[32];
 655         const char propname[32];
 656         int offset;
 657         int size;
 658 };
 659
 660 static __initdata struct params fdt_params[] = {
 661         UEFI_PARAM("System Table", "linux,uefi-system-table", system_table),
 662         UEFI_PARAM("MemMap Address", "linux,uefi-mmap-start", mmap),
 663         UEFI_PARAM("MemMap Size", "linux,uefi-mmap-size", mmap_size),
 664         UEFI_PARAM("MemMap Desc. Size", "linux,uefi-mmap-desc-size", desc_size),
 665         UEFI_PARAM("MemMap Desc. Version", "linux,uefi-mmap-desc-ver", desc_ver)
 666 };
 667
 668 static __initdata struct params xen_fdt_params[] = {
 669         UEFI_PARAM("System Table", "xen,uefi-system-table", system_table),
 670         UEFI_PARAM("MemMap Address", "xen,uefi-mmap-start", mmap),
 671         UEFI_PARAM("MemMap Size", "xen,uefi-mmap-size", mmap_size),
 672         UEFI_PARAM("MemMap Desc. Size", "xen,uefi-mmap-desc-size", desc_size),
 673         UEFI_PARAM("MemMap Desc. Version", "xen,uefi-mmap-desc-ver", desc_ver)
 674 };
 675
 676 #define EFI_FDT_PARAMS_SIZE     ARRAY_SIZE(fdt_params)
 677
 678 static __initdata struct {
 679         const char *uname;
 680         const char *subnode;
 681         struct params *params;
 682 } dt_params[] = {
 683         { "hypervisor", "uefi", xen_fdt_params },
 684         { "chosen", NULL, fdt_params },
 685 };
 686
 687 struct param_info {
 688         int found;
 689         void *params;
 690         const char *missing;
 691 };
 692
 693 static int __init __find_uefi_params(unsigned long node,
 694                                      struct param_info *info,
 695                                      struct params *params)
 696 {
 697         const void *prop;
 698         void *dest;
 699         u64 val;
 700         int i, len;
 701
 702         for (i = 0; i < EFI_FDT_PARAMS_SIZE; i++) {
 703                 prop = of_get_flat_dt_prop(node, params[i].propname, &len);
 704                 if (!prop) {
 705                         info->missing = params[i].name;
 706                         return 0;
 707                 }
 708
 709                 dest = info->params + params[i].offset;
 710                 info->found++;
 711
 712                 val = of_read_number(prop, len / sizeof(u32));
 713
 714                 if (params[i].size == sizeof(u32))
 715                         *(u32 *)dest = val;
 716                 else
 717                         *(u64 *)dest = val;
 718
 719                 if (efi_enabled(EFI_DBG))
 720                         pr_info("  %s: 0x%0*llx\n", params[i].name,
 721                                 params[i].size * 2, val);
 722         }
 723
 724         return 1;
 725 }
 726
 727 static int __init fdt_find_uefi_params(unsigned long node, const char *uname,
 728                                        int depth, void *data)
 729 {
 730         struct param_info *info = data;
 731         int i;
 732
 733         for (i = 0; i < ARRAY_SIZE(dt_params); i++) {
 734                 const char *subnode = dt_params[i].subnode;
 735
 736                 if (depth != 1 || strcmp(uname, dt_params[i].uname) != 0) {
 737                         info->missing = dt_params[i].params[0].name;
 738                         continue;
 739                 }
 740
 741                 if (subnode) {
 742                         int err = of_get_flat_dt_subnode_by_name(node, subnode);
 743
 744                         if (err < 0)
 745                                 return 0;
 746
 747                         node = err;
 748                 }
 749
 750                 return __find_uefi_params(node, info, dt_params[i].params);
 751         }
 752
 753         return 0;
 754 }
 755
 756 int __init efi_get_fdt_params(struct efi_fdt_params *params)
 757 {
 758         struct param_info info;
 759         int ret;
 760
 761         pr_info("Getting EFI parameters from FDT:\n");
 762
 763         info.found = 0;
 764         info.params = params;
 765
 766         ret = of_scan_flat_dt(fdt_find_uefi_params, &info);
 767         if (!info.found)
 768                 pr_info("UEFI not found.\n");
 769         else if (!ret)
 770                 pr_err("Can't find '%s' in device tree!\n",
 771                        info.missing);
 772
 773         return ret;
 774 }
 775 #endif /* CONFIG_EFI_PARAMS_FROM_FDT */
 776
 777 static __initdata char memory_type_name[][20] = {
 778         "Reserved",
 779         "Loader Code",
 780         "Loader Data",
 781         "Boot Code",
 782         "Boot Data",
 783         "Runtime Code",
 784         "Runtime Data",
 785         "Conventional Memory",
 786         "Unusable Memory",
 787         "ACPI Reclaim Memory",
 788         "ACPI Memory NVS",
 789         "Memory Mapped I/O",
 790         "MMIO Port Space",
 791         "PAL Code",
 792         "Persistent Memory",
 793 };
 794
 795 char * __init efi_md_typeattr_format(char *buf, size_t size,
 796                                      const efi_memory_desc_t *md)
 797 {
 798         char *pos;
 799         int type_len;
 800         u64 attr;
 801
 802         pos = buf;
 803         if (md->type >= ARRAY_SIZE(memory_type_name))
 804                 type_len = snprintf(pos, size, "[type=%u", md->type);
 805         else
 806                 type_len = snprintf(pos, size, "[%-*s",
 807                                     (int)(sizeof(memory_type_name[0]) - 1),
 808                                     memory_type_name[md->type]);
 809         if (type_len >= size)
 810                 return buf;
 811
 812         pos += type_len;
 813         size -= type_len;
 814
 815         attr = md->attribute;
 816         if (attr & ~(EFI_MEMORY_UC | EFI_MEMORY_WC | EFI_MEMORY_WT |
 817                      EFI_MEMORY_WB | EFI_MEMORY_UCE | EFI_MEMORY_RO |
 818                      EFI_MEMORY_WP | EFI_MEMORY_RP | EFI_MEMORY_XP |
 819                      EFI_MEMORY_NV |
 820                      EFI_MEMORY_RUNTIME | EFI_MEMORY_MORE_RELIABLE))
 821                 snprintf(pos, size, "|attr=0x%016llx]",
 822                          (unsigned long long)attr);
 823         else
 824                 snprintf(pos, size,
 825                          "|%3s|%2s|%2s|%2s|%2s|%2s|%2s|%3s|%2s|%2s|%2s|%2s]",
 826                          attr & EFI_MEMORY_RUNTIME ? "RUN" : "",
 827                          attr & EFI_MEMORY_MORE_RELIABLE ? "MR" : "",
 828                          attr & EFI_MEMORY_NV      ? "NV"  : "",
 829                          attr & EFI_MEMORY_XP      ? "XP"  : "",
 830                          attr & EFI_MEMORY_RP      ? "RP"  : "",
 831                          attr & EFI_MEMORY_WP      ? "WP"  : "",
 832                          attr & EFI_MEMORY_RO      ? "RO"  : "",
 833                          attr & EFI_MEMORY_UCE     ? "UCE" : "",
 834                          attr & EFI_MEMORY_WB      ? "WB"  : "",
 835                          attr & EFI_MEMORY_WT      ? "WT"  : "",
 836                          attr & EFI_MEMORY_WC      ? "WC"  : "",
 837                          attr & EFI_MEMORY_UC      ? "UC"  : "");
 838         return buf;
 839 }
 840
 841 /*
 842  * IA64 has a funky EFI memory map that doesn't work the same way as
 843  * other architectures.
 844  */
 845 #ifndef CONFIG_IA64
 846 /*
 847  * efi_mem_attributes - lookup memmap attributes for physical address
 848  * @phys_addr: the physical address to lookup
 849  *
 850  * Search in the EFI memory map for the region covering
 851  * @phys_addr. Returns the EFI memory attributes if the region
 852  * was found in the memory map, 0 otherwise.
 853  */
 854 u64 efi_mem_attributes(unsigned long phys_addr)
 855 {
 856         efi_memory_desc_t *md;
 857
 858         if (!efi_enabled(EFI_MEMMAP))
 859                 return 0;
 860
 861         for_each_efi_memory_desc(md) {
 862                 if ((md->phys_addr <= phys_addr) &&
 863                     (phys_addr < (md->phys_addr +
 864                     (md->num_pages << EFI_PAGE_SHIFT))))
 865                         return md->attribute;
 866         }
 867         return 0;
 868 }
 869
 870 /*
 871  * efi_mem_type - lookup memmap type for physical address
 872  * @phys_addr: the physical address to lookup
 873  *
 874  * Search in the EFI memory map for the region covering @phys_addr.
 875  * Returns the EFI memory type if the region was found in the memory
 876  * map, EFI_RESERVED_TYPE (zero) otherwise.
 877  */
 878 int efi_mem_type(unsigned long phys_addr)
 879 {
 880         const efi_memory_desc_t *md;
 881
 882         if (!efi_enabled(EFI_MEMMAP))
 883                 return -ENOTSUPP;
 884
 885         for_each_efi_memory_desc(md) {
 886                 if ((md->phys_addr <= phys_addr) &&
 887                     (phys_addr < (md->phys_addr +
 888                                   (md->num_pages << EFI_PAGE_SHIFT))))
 889                         return md->type;
 890         }
 891         return -EINVAL;
 892 }
 893 #endif
 894
 895 int efi_status_to_err(efi_status_t status)
 896 {
 897         int err;
 898
 899         switch (status) {
 900         case EFI_SUCCESS:
 901                 err = 0;
 902                 break;
 903         case EFI_INVALID_PARAMETER:
 904                 err = -EINVAL;
 905                 break;
 906         case EFI_OUT_OF_RESOURCES:
 907                 err = -ENOSPC;
 908                 break;
 909         case EFI_DEVICE_ERROR:
 910                 err = -EIO;
 911                 break;
 912         case EFI_WRITE_PROTECTED:
 913                 err = -EROFS;
 914                 break;
 915         case EFI_SECURITY_VIOLATION:
 916                 err = -EACCES;
 917                 break;
 918         case EFI_NOT_FOUND:
 919                 err = -ENOENT;
 920                 break;
 921         case EFI_ABORTED:
 922                 err = -EINTR;
 923                 break;
 924         default:
 925                 err = -EINVAL;
 926         }
 927
 928         return err;
 929 }
 930
 931 bool efi_is_table_address(unsigned long phys_addr)
 932 {
 933         unsigned int i;
 934
 935         if (phys_addr == EFI_INVALID_TABLE_ADDR)
 936                 return false;
 937
 938         for (i = 0; i < ARRAY_SIZE(efi_tables); i++)
 939                 if (*(efi_tables[i]) == phys_addr)
 940                         return true;
 941
 942         return false;
 943 }
 944
 945 #ifdef CONFIG_KEXEC
 946 static int update_efi_random_seed(struct notifier_block *nb,
 947                                   unsigned long code, void *unused)
 948 {
 949         struct linux_efi_random_seed *seed;
 950         u32 size = 0;
 951
 952         if (!kexec_in_progress)
 953                 return NOTIFY_DONE;
 954
 955         seed = memremap(efi.rng_seed, sizeof(*seed), MEMREMAP_WB);
 956         if (seed != NULL) {
 957                 size = min(seed->size, EFI_RANDOM_SEED_SIZE);
 958                 memunmap(seed);
 959         } else {
 960                 pr_err("Could not map UEFI random seed!\n");
 961         }
 962         if (size > 0) {
 963                 seed = memremap(efi.rng_seed, sizeof(*seed) + size,
 964                                 MEMREMAP_WB);
 965                 if (seed != NULL) {
 966                         seed->size = size;
 967                         get_random_bytes(seed->bits, seed->size);
 968                         memunmap(seed);
 969                 } else {
 970                         pr_err("Could not map UEFI random seed!\n");
 971                 }
 972         }
 973         return NOTIFY_DONE;
 974 }
 975
 976 static struct notifier_block efi_random_seed_nb = {
 977         .notifier_call = update_efi_random_seed,
 978 };
 979
 980 static int register_update_efi_random_seed(void)
 981 {
 982         if (efi.rng_seed == EFI_INVALID_TABLE_ADDR)
 983                 return 0;
 984         return register_reboot_notifier(&efi_random_seed_nb);
 985 }
 986 late_initcall(register_update_efi_random_seed);
 987 #endif