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