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