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