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