drivers/firmware/efi/efi.c

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