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