drivers/firmware/efi/efi.c

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