drivers/firmware/efi/efi.c

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