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