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 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 } else { 545 pr_err("Could not map UEFI random seed!\n"); 546 } 547 } 548 } 549 550 if (efi_enabled(EFI_MEMMAP)) 551 efi_memattr_init(); 552 553 /* Parse the EFI Properties table if it exists */ 554 if (efi.properties_table != EFI_INVALID_TABLE_ADDR) { 555 efi_properties_table_t *tbl; 556 557 tbl = early_memremap(efi.properties_table, sizeof(*tbl)); 558 if (tbl == NULL) { 559 pr_err("Could not map Properties table!\n"); 560 return -ENOMEM; 561 } 562 563 if (tbl->memory_protection_attribute & 564 EFI_PROPERTIES_RUNTIME_MEMORY_PROTECTION_NON_EXECUTABLE_PE_DATA) 565 set_bit(EFI_NX_PE_DATA, &efi.flags); 566 567 early_memunmap(tbl, sizeof(*tbl)); 568 } 569 570 return 0; 571 } 572 573 int __init efi_config_init(efi_config_table_type_t *arch_tables) 574 { 575 void *config_tables; 576 int sz, ret; 577 578 if (efi_enabled(EFI_64BIT)) 579 sz = sizeof(efi_config_table_64_t); 580 else 581 sz = sizeof(efi_config_table_32_t); 582 583 /* 584 * Let's see what config tables the firmware passed to us. 585 */ 586 config_tables = early_memremap(efi.systab->tables, 587 efi.systab->nr_tables * sz); 588 if (config_tables == NULL) { 589 pr_err("Could not map Configuration table!\n"); 590 return -ENOMEM; 591 } 592 593 ret = efi_config_parse_tables(config_tables, efi.systab->nr_tables, sz, 594 arch_tables); 595 596 early_memunmap(config_tables, efi.systab->nr_tables * sz); 597 return ret; 598 } 599 600 #ifdef CONFIG_EFI_VARS_MODULE 601 static int __init efi_load_efivars(void) 602 { 603 struct platform_device *pdev; 604 605 if (!efi_enabled(EFI_RUNTIME_SERVICES)) 606 return 0; 607 608 pdev = platform_device_register_simple("efivars", 0, NULL, 0); 609 return IS_ERR(pdev) ? PTR_ERR(pdev) : 0; 610 } 611 device_initcall(efi_load_efivars); 612 #endif 613 614 #ifdef CONFIG_EFI_PARAMS_FROM_FDT 615 616 #define UEFI_PARAM(name, prop, field) \ 617 { \ 618 { name }, \ 619 { prop }, \ 620 offsetof(struct efi_fdt_params, field), \ 621 FIELD_SIZEOF(struct efi_fdt_params, field) \ 622 } 623 624 struct params { 625 const char name[32]; 626 const char propname[32]; 627 int offset; 628 int size; 629 }; 630 631 static __initdata struct params fdt_params[] = { 632 UEFI_PARAM("System Table", "linux,uefi-system-table", system_table), 633 UEFI_PARAM("MemMap Address", "linux,uefi-mmap-start", mmap), 634 UEFI_PARAM("MemMap Size", "linux,uefi-mmap-size", mmap_size), 635 UEFI_PARAM("MemMap Desc. Size", "linux,uefi-mmap-desc-size", desc_size), 636 UEFI_PARAM("MemMap Desc. Version", "linux,uefi-mmap-desc-ver", desc_ver) 637 }; 638 639 static __initdata struct params xen_fdt_params[] = { 640 UEFI_PARAM("System Table", "xen,uefi-system-table", system_table), 641 UEFI_PARAM("MemMap Address", "xen,uefi-mmap-start", mmap), 642 UEFI_PARAM("MemMap Size", "xen,uefi-mmap-size", mmap_size), 643 UEFI_PARAM("MemMap Desc. Size", "xen,uefi-mmap-desc-size", desc_size), 644 UEFI_PARAM("MemMap Desc. Version", "xen,uefi-mmap-desc-ver", desc_ver) 645 }; 646 647 #define EFI_FDT_PARAMS_SIZE ARRAY_SIZE(fdt_params) 648 649 static __initdata struct { 650 const char *uname; 651 const char *subnode; 652 struct params *params; 653 } dt_params[] = { 654 { "hypervisor", "uefi", xen_fdt_params }, 655 { "chosen", NULL, fdt_params }, 656 }; 657 658 struct param_info { 659 int found; 660 void *params; 661 const char *missing; 662 }; 663 664 static int __init __find_uefi_params(unsigned long node, 665 struct param_info *info, 666 struct params *params) 667 { 668 const void *prop; 669 void *dest; 670 u64 val; 671 int i, len; 672 673 for (i = 0; i < EFI_FDT_PARAMS_SIZE; i++) { 674 prop = of_get_flat_dt_prop(node, params[i].propname, &len); 675 if (!prop) { 676 info->missing = params[i].name; 677 return 0; 678 } 679 680 dest = info->params + params[i].offset; 681 info->found++; 682 683 val = of_read_number(prop, len / sizeof(u32)); 684 685 if (params[i].size == sizeof(u32)) 686 *(u32 *)dest = val; 687 else 688 *(u64 *)dest = val; 689 690 if (efi_enabled(EFI_DBG)) 691 pr_info(" %s: 0x%0*llx\n", params[i].name, 692 params[i].size * 2, val); 693 } 694 695 return 1; 696 } 697 698 static int __init fdt_find_uefi_params(unsigned long node, const char *uname, 699 int depth, void *data) 700 { 701 struct param_info *info = data; 702 int i; 703 704 for (i = 0; i < ARRAY_SIZE(dt_params); i++) { 705 const char *subnode = dt_params[i].subnode; 706 707 if (depth != 1 || strcmp(uname, dt_params[i].uname) != 0) { 708 info->missing = dt_params[i].params[0].name; 709 continue; 710 } 711 712 if (subnode) { 713 int err = of_get_flat_dt_subnode_by_name(node, subnode); 714 715 if (err < 0) 716 return 0; 717 718 node = err; 719 } 720 721 return __find_uefi_params(node, info, dt_params[i].params); 722 } 723 724 return 0; 725 } 726 727 int __init efi_get_fdt_params(struct efi_fdt_params *params) 728 { 729 struct param_info info; 730 int ret; 731 732 pr_info("Getting EFI parameters from FDT:\n"); 733 734 info.found = 0; 735 info.params = params; 736 737 ret = of_scan_flat_dt(fdt_find_uefi_params, &info); 738 if (!info.found) 739 pr_info("UEFI not found.\n"); 740 else if (!ret) 741 pr_err("Can't find '%s' in device tree!\n", 742 info.missing); 743 744 return ret; 745 } 746 #endif /* CONFIG_EFI_PARAMS_FROM_FDT */ 747 748 static __initdata char memory_type_name[][20] = { 749 "Reserved", 750 "Loader Code", 751 "Loader Data", 752 "Boot Code", 753 "Boot Data", 754 "Runtime Code", 755 "Runtime Data", 756 "Conventional Memory", 757 "Unusable Memory", 758 "ACPI Reclaim Memory", 759 "ACPI Memory NVS", 760 "Memory Mapped I/O", 761 "MMIO Port Space", 762 "PAL Code", 763 "Persistent Memory", 764 }; 765 766 char * __init efi_md_typeattr_format(char *buf, size_t size, 767 const efi_memory_desc_t *md) 768 { 769 char *pos; 770 int type_len; 771 u64 attr; 772 773 pos = buf; 774 if (md->type >= ARRAY_SIZE(memory_type_name)) 775 type_len = snprintf(pos, size, "[type=%u", md->type); 776 else 777 type_len = snprintf(pos, size, "[%-*s", 778 (int)(sizeof(memory_type_name[0]) - 1), 779 memory_type_name[md->type]); 780 if (type_len >= size) 781 return buf; 782 783 pos += type_len; 784 size -= type_len; 785 786 attr = md->attribute; 787 if (attr & ~(EFI_MEMORY_UC | EFI_MEMORY_WC | EFI_MEMORY_WT | 788 EFI_MEMORY_WB | EFI_MEMORY_UCE | EFI_MEMORY_RO | 789 EFI_MEMORY_WP | EFI_MEMORY_RP | EFI_MEMORY_XP | 790 EFI_MEMORY_NV | 791 EFI_MEMORY_RUNTIME | EFI_MEMORY_MORE_RELIABLE)) 792 snprintf(pos, size, "|attr=0x%016llx]", 793 (unsigned long long)attr); 794 else 795 snprintf(pos, size, 796 "|%3s|%2s|%2s|%2s|%2s|%2s|%2s|%3s|%2s|%2s|%2s|%2s]", 797 attr & EFI_MEMORY_RUNTIME ? "RUN" : "", 798 attr & EFI_MEMORY_MORE_RELIABLE ? "MR" : "", 799 attr & EFI_MEMORY_NV ? "NV" : "", 800 attr & EFI_MEMORY_XP ? "XP" : "", 801 attr & EFI_MEMORY_RP ? "RP" : "", 802 attr & EFI_MEMORY_WP ? "WP" : "", 803 attr & EFI_MEMORY_RO ? "RO" : "", 804 attr & EFI_MEMORY_UCE ? "UCE" : "", 805 attr & EFI_MEMORY_WB ? "WB" : "", 806 attr & EFI_MEMORY_WT ? "WT" : "", 807 attr & EFI_MEMORY_WC ? "WC" : "", 808 attr & EFI_MEMORY_UC ? "UC" : ""); 809 return buf; 810 } 811 812 /* 813 * efi_mem_attributes - lookup memmap attributes for physical address 814 * @phys_addr: the physical address to lookup 815 * 816 * Search in the EFI memory map for the region covering 817 * @phys_addr. Returns the EFI memory attributes if the region 818 * was found in the memory map, 0 otherwise. 819 * 820 * Despite being marked __weak, most architectures should *not* 821 * override this function. It is __weak solely for the benefit 822 * of ia64 which has a funky EFI memory map that doesn't work 823 * the same way as other architectures. 824 */ 825 u64 __weak efi_mem_attributes(unsigned long phys_addr) 826 { 827 efi_memory_desc_t *md; 828 829 if (!efi_enabled(EFI_MEMMAP)) 830 return 0; 831 832 for_each_efi_memory_desc(md) { 833 if ((md->phys_addr <= phys_addr) && 834 (phys_addr < (md->phys_addr + 835 (md->num_pages << EFI_PAGE_SHIFT)))) 836 return md->attribute; 837 } 838 return 0; 839 } 840 841 int efi_status_to_err(efi_status_t status) 842 { 843 int err; 844 845 switch (status) { 846 case EFI_SUCCESS: 847 err = 0; 848 break; 849 case EFI_INVALID_PARAMETER: 850 err = -EINVAL; 851 break; 852 case EFI_OUT_OF_RESOURCES: 853 err = -ENOSPC; 854 break; 855 case EFI_DEVICE_ERROR: 856 err = -EIO; 857 break; 858 case EFI_WRITE_PROTECTED: 859 err = -EROFS; 860 break; 861 case EFI_SECURITY_VIOLATION: 862 err = -EACCES; 863 break; 864 case EFI_NOT_FOUND: 865 err = -ENOENT; 866 break; 867 case EFI_ABORTED: 868 err = -EINTR; 869 break; 870 default: 871 err = -EINVAL; 872 } 873 874 return err; 875 } 876 877 bool efi_is_table_address(unsigned long phys_addr) 878 { 879 unsigned int i; 880 881 if (phys_addr == EFI_INVALID_TABLE_ADDR) 882 return false; 883 884 for (i = 0; i < ARRAY_SIZE(efi_tables); i++) 885 if (*(efi_tables[i]) == phys_addr) 886 return true; 887 888 return false; 889 } 890 891 #ifdef CONFIG_KEXEC 892 static int update_efi_random_seed(struct notifier_block *nb, 893 unsigned long code, void *unused) 894 { 895 struct linux_efi_random_seed *seed; 896 u32 size = 0; 897 898 if (!kexec_in_progress) 899 return NOTIFY_DONE; 900 901 seed = memremap(efi.rng_seed, sizeof(*seed), MEMREMAP_WB); 902 if (seed != NULL) { 903 size = min(seed->size, 32U); 904 memunmap(seed); 905 } else { 906 pr_err("Could not map UEFI random seed!\n"); 907 } 908 if (size > 0) { 909 seed = memremap(efi.rng_seed, sizeof(*seed) + size, 910 MEMREMAP_WB); 911 if (seed != NULL) { 912 seed->size = size; 913 get_random_bytes(seed->bits, seed->size); 914 memunmap(seed); 915 } else { 916 pr_err("Could not map UEFI random seed!\n"); 917 } 918 } 919 return NOTIFY_DONE; 920 } 921 922 static struct notifier_block efi_random_seed_nb = { 923 .notifier_call = update_efi_random_seed, 924 }; 925 926 static int register_update_efi_random_seed(void) 927 { 928 if (efi.rng_seed == EFI_INVALID_TABLE_ADDR) 929 return 0; 930 return register_reboot_notifier(&efi_random_seed_nb); 931 } 932 late_initcall(register_update_efi_random_seed); 933 #endif 934