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