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         .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                         u8 *p;
 602                         int i;
 603
 604                         /*
 605                          * Just map a full page: that is what we will get
 606                          * anyway, and it permits us to map the entire entry
 607                          * before knowing its size.
 608                          */
 609                         p = early_memremap(ALIGN_DOWN(prsv, PAGE_SIZE),
 610                                            PAGE_SIZE);
 611                         if (p == NULL) {
 612                                 pr_err("Could not map UEFI memreserve entry!\n");
 613                                 return -ENOMEM;
 614                         }
 615
 616                         rsv = (void *)(p + prsv % PAGE_SIZE);
 617
 618                         /* reserve the entry itself */
 619                         memblock_reserve(prsv, EFI_MEMRESERVE_SIZE(rsv->size));
 620
 621                         for (i = 0; i < atomic_read(&rsv->count); i++) {
 622                                 memblock_reserve(rsv->entry[i].base,
 623                                                  rsv->entry[i].size);
 624                         }
 625
 626                         prsv = rsv->next;
 627                         early_memunmap(p, PAGE_SIZE);
 628                 }
 629         }
 630
 631         return 0;
 632 }
 633
 634 int __init efi_config_init(efi_config_table_type_t *arch_tables)
 635 {
 636         void *config_tables;
 637         int sz, ret;
 638
 639         if (efi_enabled(EFI_64BIT))
 640                 sz = sizeof(efi_config_table_64_t);
 641         else
 642                 sz = sizeof(efi_config_table_32_t);
 643
 644         /*
 645          * Let's see what config tables the firmware passed to us.
 646          */
 647         config_tables = early_memremap(efi.systab->tables,
 648                                        efi.systab->nr_tables * sz);
 649         if (config_tables == NULL) {
 650                 pr_err("Could not map Configuration table!\n");
 651                 return -ENOMEM;
 652         }
 653
 654         ret = efi_config_parse_tables(config_tables, efi.systab->nr_tables, sz,
 655                                       arch_tables);
 656
 657         early_memunmap(config_tables, efi.systab->nr_tables * sz);
 658         return ret;
 659 }
 660
 661 #ifdef CONFIG_EFI_VARS_MODULE
 662 static int __init efi_load_efivars(void)
 663 {
 664         struct platform_device *pdev;
 665
 666         if (!efi_enabled(EFI_RUNTIME_SERVICES))
 667                 return 0;
 668
 669         pdev = platform_device_register_simple("efivars", 0, NULL, 0);
 670         return PTR_ERR_OR_ZERO(pdev);
 671 }
 672 device_initcall(efi_load_efivars);
 673 #endif
 674
 675 #ifdef CONFIG_EFI_PARAMS_FROM_FDT
 676
 677 #define UEFI_PARAM(name, prop, field)                      \
 678         {                                                  \
 679                 { name },                                  \
 680                 { prop },                                  \
 681                 offsetof(struct efi_fdt_params, field),    \
 682                 FIELD_SIZEOF(struct efi_fdt_params, field) \
 683         }
 684
 685 struct params {
 686         const char name[32];
 687         const char propname[32];
 688         int offset;
 689         int size;
 690 };
 691
 692 static __initdata struct params fdt_params[] = {
 693         UEFI_PARAM("System Table", "linux,uefi-system-table", system_table),
 694         UEFI_PARAM("MemMap Address", "linux,uefi-mmap-start", mmap),
 695         UEFI_PARAM("MemMap Size", "linux,uefi-mmap-size", mmap_size),
 696         UEFI_PARAM("MemMap Desc. Size", "linux,uefi-mmap-desc-size", desc_size),
 697         UEFI_PARAM("MemMap Desc. Version", "linux,uefi-mmap-desc-ver", desc_ver)
 698 };
 699
 700 static __initdata struct params xen_fdt_params[] = {
 701         UEFI_PARAM("System Table", "xen,uefi-system-table", system_table),
 702         UEFI_PARAM("MemMap Address", "xen,uefi-mmap-start", mmap),
 703         UEFI_PARAM("MemMap Size", "xen,uefi-mmap-size", mmap_size),
 704         UEFI_PARAM("MemMap Desc. Size", "xen,uefi-mmap-desc-size", desc_size),
 705         UEFI_PARAM("MemMap Desc. Version", "xen,uefi-mmap-desc-ver", desc_ver)
 706 };
 707
 708 #define EFI_FDT_PARAMS_SIZE     ARRAY_SIZE(fdt_params)
 709
 710 static __initdata struct {
 711         const char *uname;
 712         const char *subnode;
 713         struct params *params;
 714 } dt_params[] = {
 715         { "hypervisor", "uefi", xen_fdt_params },
 716         { "chosen", NULL, fdt_params },
 717 };
 718
 719 struct param_info {
 720         int found;
 721         void *params;
 722         const char *missing;
 723 };
 724
 725 static int __init __find_uefi_params(unsigned long node,
 726                                      struct param_info *info,
 727                                      struct params *params)
 728 {
 729         const void *prop;
 730         void *dest;
 731         u64 val;
 732         int i, len;
 733
 734         for (i = 0; i < EFI_FDT_PARAMS_SIZE; i++) {
 735                 prop = of_get_flat_dt_prop(node, params[i].propname, &len);
 736                 if (!prop) {
 737                         info->missing = params[i].name;
 738                         return 0;
 739                 }
 740
 741                 dest = info->params + params[i].offset;
 742                 info->found++;
 743
 744                 val = of_read_number(prop, len / sizeof(u32));
 745
 746                 if (params[i].size == sizeof(u32))
 747                         *(u32 *)dest = val;
 748                 else
 749                         *(u64 *)dest = val;
 750
 751                 if (efi_enabled(EFI_DBG))
 752                         pr_info("  %s: 0x%0*llx\n", params[i].name,
 753                                 params[i].size * 2, val);
 754         }
 755
 756         return 1;
 757 }
 758
 759 static int __init fdt_find_uefi_params(unsigned long node, const char *uname,
 760                                        int depth, void *data)
 761 {
 762         struct param_info *info = data;
 763         int i;
 764
 765         for (i = 0; i < ARRAY_SIZE(dt_params); i++) {
 766                 const char *subnode = dt_params[i].subnode;
 767
 768                 if (depth != 1 || strcmp(uname, dt_params[i].uname) != 0) {
 769                         info->missing = dt_params[i].params[0].name;
 770                         continue;
 771                 }
 772
 773                 if (subnode) {
 774                         int err = of_get_flat_dt_subnode_by_name(node, subnode);
 775
 776                         if (err < 0)
 777                                 return 0;
 778
 779                         node = err;
 780                 }
 781
 782                 return __find_uefi_params(node, info, dt_params[i].params);
 783         }
 784
 785         return 0;
 786 }
 787
 788 int __init efi_get_fdt_params(struct efi_fdt_params *params)
 789 {
 790         struct param_info info;
 791         int ret;
 792
 793         pr_info("Getting EFI parameters from FDT:\n");
 794
 795         info.found = 0;
 796         info.params = params;
 797
 798         ret = of_scan_flat_dt(fdt_find_uefi_params, &info);
 799         if (!info.found)
 800                 pr_info("UEFI not found.\n");
 801         else if (!ret)
 802                 pr_err("Can't find '%s' in device tree!\n",
 803                        info.missing);
 804
 805         return ret;
 806 }
 807 #endif /* CONFIG_EFI_PARAMS_FROM_FDT */
 808
 809 static __initdata char memory_type_name[][20] = {
 810         "Reserved",
 811         "Loader Code",
 812         "Loader Data",
 813         "Boot Code",
 814         "Boot Data",
 815         "Runtime Code",
 816         "Runtime Data",
 817         "Conventional Memory",
 818         "Unusable Memory",
 819         "ACPI Reclaim Memory",
 820         "ACPI Memory NVS",
 821         "Memory Mapped I/O",
 822         "MMIO Port Space",
 823         "PAL Code",
 824         "Persistent Memory",
 825 };
 826
 827 char * __init efi_md_typeattr_format(char *buf, size_t size,
 828                                      const efi_memory_desc_t *md)
 829 {
 830         char *pos;
 831         int type_len;
 832         u64 attr;
 833
 834         pos = buf;
 835         if (md->type >= ARRAY_SIZE(memory_type_name))
 836                 type_len = snprintf(pos, size, "[type=%u", md->type);
 837         else
 838                 type_len = snprintf(pos, size, "[%-*s",
 839                                     (int)(sizeof(memory_type_name[0]) - 1),
 840                                     memory_type_name[md->type]);
 841         if (type_len >= size)
 842                 return buf;
 843
 844         pos += type_len;
 845         size -= type_len;
 846
 847         attr = md->attribute;
 848         if (attr & ~(EFI_MEMORY_UC | EFI_MEMORY_WC | EFI_MEMORY_WT |
 849                      EFI_MEMORY_WB | EFI_MEMORY_UCE | EFI_MEMORY_RO |
 850                      EFI_MEMORY_WP | EFI_MEMORY_RP | EFI_MEMORY_XP |
 851                      EFI_MEMORY_NV |
 852                      EFI_MEMORY_RUNTIME | EFI_MEMORY_MORE_RELIABLE))
 853                 snprintf(pos, size, "|attr=0x%016llx]",
 854                          (unsigned long long)attr);
 855         else
 856                 snprintf(pos, size,
 857                          "|%3s|%2s|%2s|%2s|%2s|%2s|%2s|%3s|%2s|%2s|%2s|%2s]",
 858                          attr & EFI_MEMORY_RUNTIME ? "RUN" : "",
 859                          attr & EFI_MEMORY_MORE_RELIABLE ? "MR" : "",
 860                          attr & EFI_MEMORY_NV      ? "NV"  : "",
 861                          attr & EFI_MEMORY_XP      ? "XP"  : "",
 862                          attr & EFI_MEMORY_RP      ? "RP"  : "",
 863                          attr & EFI_MEMORY_WP      ? "WP"  : "",
 864                          attr & EFI_MEMORY_RO      ? "RO"  : "",
 865                          attr & EFI_MEMORY_UCE     ? "UCE" : "",
 866                          attr & EFI_MEMORY_WB      ? "WB"  : "",
 867                          attr & EFI_MEMORY_WT      ? "WT"  : "",
 868                          attr & EFI_MEMORY_WC      ? "WC"  : "",
 869                          attr & EFI_MEMORY_UC      ? "UC"  : "");
 870         return buf;
 871 }
 872
 873 /*
 874  * IA64 has a funky EFI memory map that doesn't work the same way as
 875  * other architectures.
 876  */
 877 #ifndef CONFIG_IA64
 878 /*
 879  * efi_mem_attributes - lookup memmap attributes for physical address
 880  * @phys_addr: the physical address to lookup
 881  *
 882  * Search in the EFI memory map for the region covering
 883  * @phys_addr. Returns the EFI memory attributes if the region
 884  * was found in the memory map, 0 otherwise.
 885  */
 886 u64 efi_mem_attributes(unsigned long phys_addr)
 887 {
 888         efi_memory_desc_t *md;
 889
 890         if (!efi_enabled(EFI_MEMMAP))
 891                 return 0;
 892
 893         for_each_efi_memory_desc(md) {
 894                 if ((md->phys_addr <= phys_addr) &&
 895                     (phys_addr < (md->phys_addr +
 896                     (md->num_pages << EFI_PAGE_SHIFT))))
 897                         return md->attribute;
 898         }
 899         return 0;
 900 }
 901
 902 /*
 903  * efi_mem_type - lookup memmap type for physical address
 904  * @phys_addr: the physical address to lookup
 905  *
 906  * Search in the EFI memory map for the region covering @phys_addr.
 907  * Returns the EFI memory type if the region was found in the memory
 908  * map, EFI_RESERVED_TYPE (zero) otherwise.
 909  */
 910 int efi_mem_type(unsigned long phys_addr)
 911 {
 912         const efi_memory_desc_t *md;
 913
 914         if (!efi_enabled(EFI_MEMMAP))
 915                 return -ENOTSUPP;
 916
 917         for_each_efi_memory_desc(md) {
 918                 if ((md->phys_addr <= phys_addr) &&
 919                     (phys_addr < (md->phys_addr +
 920                                   (md->num_pages << EFI_PAGE_SHIFT))))
 921                         return md->type;
 922         }
 923         return -EINVAL;
 924 }
 925 #endif
 926
 927 int efi_status_to_err(efi_status_t status)
 928 {
 929         int err;
 930
 931         switch (status) {
 932         case EFI_SUCCESS:
 933                 err = 0;
 934                 break;
 935         case EFI_INVALID_PARAMETER:
 936                 err = -EINVAL;
 937                 break;
 938         case EFI_OUT_OF_RESOURCES:
 939                 err = -ENOSPC;
 940                 break;
 941         case EFI_DEVICE_ERROR:
 942                 err = -EIO;
 943                 break;
 944         case EFI_WRITE_PROTECTED:
 945                 err = -EROFS;
 946                 break;
 947         case EFI_SECURITY_VIOLATION:
 948                 err = -EACCES;
 949                 break;
 950         case EFI_NOT_FOUND:
 951                 err = -ENOENT;
 952                 break;
 953         case EFI_ABORTED:
 954                 err = -EINTR;
 955                 break;
 956         default:
 957                 err = -EINVAL;
 958         }
 959
 960         return err;
 961 }
 962
 963 bool efi_is_table_address(unsigned long phys_addr)
 964 {
 965         unsigned int i;
 966
 967         if (phys_addr == EFI_INVALID_TABLE_ADDR)
 968                 return false;
 969
 970         for (i = 0; i < ARRAY_SIZE(efi_tables); i++)
 971                 if (*(efi_tables[i]) == phys_addr)
 972                         return true;
 973
 974         return false;
 975 }
 976
 977 static DEFINE_SPINLOCK(efi_mem_reserve_persistent_lock);
 978 static struct linux_efi_memreserve *efi_memreserve_root __ro_after_init;
 979
 980 static int __init efi_memreserve_map_root(void)
 981 {
 982         if (efi.mem_reserve == EFI_INVALID_TABLE_ADDR)
 983                 return -ENODEV;
 984
 985         efi_memreserve_root = memremap(efi.mem_reserve,
 986                                        sizeof(*efi_memreserve_root),
 987                                        MEMREMAP_WB);
 988         if (WARN_ON_ONCE(!efi_memreserve_root))
 989                 return -ENOMEM;
 990         return 0;
 991 }
 992
 993 int __ref efi_mem_reserve_persistent(phys_addr_t addr, u64 size)
 994 {
 995         struct linux_efi_memreserve *rsv;
 996         unsigned long prsv;
 997         int rc, index;
 998
 999         if (efi_memreserve_root == (void *)ULONG_MAX)
1000                 return -ENODEV;
1001
1002         if (!efi_memreserve_root) {
1003                 rc = efi_memreserve_map_root();
1004                 if (rc)
1005                         return rc;
1006         }
1007
1008         /* first try to find a slot in an existing linked list entry */
1009         for (prsv = efi_memreserve_root->next; prsv; prsv = rsv->next) {
1010                 rsv = __va(prsv);
1011                 index = atomic_fetch_add_unless(&rsv->count, 1, rsv->size);
1012                 if (index < rsv->size) {
1013                         rsv->entry[index].base = addr;
1014                         rsv->entry[index].size = size;
1015
1016                         return 0;
1017                 }
1018         }
1019
1020         /* no slot found - allocate a new linked list entry */
1021         rsv = (struct linux_efi_memreserve *)__get_free_page(GFP_ATOMIC);
1022         if (!rsv)
1023                 return -ENOMEM;
1024
1025         rsv->size = EFI_MEMRESERVE_COUNT(PAGE_SIZE);
1026         atomic_set(&rsv->count, 1);
1027         rsv->entry[0].base = addr;
1028         rsv->entry[0].size = size;
1029
1030         spin_lock(&efi_mem_reserve_persistent_lock);
1031         rsv->next = efi_memreserve_root->next;
1032         efi_memreserve_root->next = __pa(rsv);
1033         spin_unlock(&efi_mem_reserve_persistent_lock);
1034
1035         return 0;
1036 }
1037
1038 static int __init efi_memreserve_root_init(void)
1039 {
1040         if (efi_memreserve_root)
1041                 return 0;
1042         if (efi_memreserve_map_root())
1043                 efi_memreserve_root = (void *)ULONG_MAX;
1044         return 0;
1045 }
1046 early_initcall(efi_memreserve_root_init);
1047
1048 #ifdef CONFIG_KEXEC
1049 static int update_efi_random_seed(struct notifier_block *nb,
1050                                   unsigned long code, void *unused)
1051 {
1052         struct linux_efi_random_seed *seed;
1053         u32 size = 0;
1054
1055         if (!kexec_in_progress)
1056                 return NOTIFY_DONE;
1057
1058         seed = memremap(efi.rng_seed, sizeof(*seed), MEMREMAP_WB);
1059         if (seed != NULL) {
1060                 size = min(seed->size, EFI_RANDOM_SEED_SIZE);
1061                 memunmap(seed);
1062         } else {
1063                 pr_err("Could not map UEFI random seed!\n");
1064         }
1065         if (size > 0) {
1066                 seed = memremap(efi.rng_seed, sizeof(*seed) + size,
1067                                 MEMREMAP_WB);
1068                 if (seed != NULL) {
1069                         seed->size = size;
1070                         get_random_bytes(seed->bits, seed->size);
1071                         memunmap(seed);
1072                 } else {
1073                         pr_err("Could not map UEFI random seed!\n");
1074                 }
1075         }
1076         return NOTIFY_DONE;
1077 }
1078
1079 static struct notifier_block efi_random_seed_nb = {
1080         .notifier_call = update_efi_random_seed,
1081 };
1082
1083 static int register_update_efi_random_seed(void)
1084 {
1085         if (efi.rng_seed == EFI_INVALID_TABLE_ADDR)
1086                 return 0;
1087         return register_reboot_notifier(&efi_random_seed_nb);
1088 }
1089 late_initcall(register_update_efi_random_seed);
1090 #endif