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