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