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 pr_err_once("requested map not found.\n"); 393 return -ENOENT; 394 } 395 396 /* 397 * Calculate the highest address of an efi memory descriptor. 398 */ 399 u64 __init efi_mem_desc_end(efi_memory_desc_t *md) 400 { 401 u64 size = md->num_pages << EFI_PAGE_SHIFT; 402 u64 end = md->phys_addr + size; 403 return end; 404 } 405 406 void __init __weak efi_arch_mem_reserve(phys_addr_t addr, u64 size) {} 407 408 /** 409 * efi_mem_reserve - Reserve an EFI memory region 410 * @addr: Physical address to reserve 411 * @size: Size of reservation 412 * 413 * Mark a region as reserved from general kernel allocation and 414 * prevent it being released by efi_free_boot_services(). 415 * 416 * This function should be called drivers once they've parsed EFI 417 * configuration tables to figure out where their data lives, e.g. 418 * efi_esrt_init(). 419 */ 420 void __init efi_mem_reserve(phys_addr_t addr, u64 size) 421 { 422 if (!memblock_is_region_reserved(addr, size)) 423 memblock_reserve(addr, size); 424 425 /* 426 * Some architectures (x86) reserve all boot services ranges 427 * until efi_free_boot_services() because of buggy firmware 428 * implementations. This means the above memblock_reserve() is 429 * superfluous on x86 and instead what it needs to do is 430 * ensure the @start, @size is not freed. 431 */ 432 efi_arch_mem_reserve(addr, size); 433 } 434 435 static __initdata efi_config_table_type_t common_tables[] = { 436 {ACPI_20_TABLE_GUID, "ACPI 2.0", &efi.acpi20}, 437 {ACPI_TABLE_GUID, "ACPI", &efi.acpi}, 438 {HCDP_TABLE_GUID, "HCDP", &efi.hcdp}, 439 {MPS_TABLE_GUID, "MPS", &efi.mps}, 440 {SAL_SYSTEM_TABLE_GUID, "SALsystab", &efi.sal_systab}, 441 {SMBIOS_TABLE_GUID, "SMBIOS", &efi.smbios}, 442 {SMBIOS3_TABLE_GUID, "SMBIOS 3.0", &efi.smbios3}, 443 {UGA_IO_PROTOCOL_GUID, "UGA", &efi.uga}, 444 {EFI_SYSTEM_RESOURCE_TABLE_GUID, "ESRT", &efi.esrt}, 445 {EFI_PROPERTIES_TABLE_GUID, "PROP", &efi.properties_table}, 446 {EFI_MEMORY_ATTRIBUTES_TABLE_GUID, "MEMATTR", &efi.mem_attr_table}, 447 {LINUX_EFI_RANDOM_SEED_TABLE_GUID, "RNG", &efi.rng_seed}, 448 {NULL_GUID, NULL, NULL}, 449 }; 450 451 static __init int match_config_table(efi_guid_t *guid, 452 unsigned long table, 453 efi_config_table_type_t *table_types) 454 { 455 int i; 456 457 if (table_types) { 458 for (i = 0; efi_guidcmp(table_types[i].guid, NULL_GUID); i++) { 459 if (!efi_guidcmp(*guid, table_types[i].guid)) { 460 *(table_types[i].ptr) = table; 461 if (table_types[i].name) 462 pr_cont(" %s=0x%lx ", 463 table_types[i].name, table); 464 return 1; 465 } 466 } 467 } 468 469 return 0; 470 } 471 472 int __init efi_config_parse_tables(void *config_tables, int count, int sz, 473 efi_config_table_type_t *arch_tables) 474 { 475 void *tablep; 476 int i; 477 478 tablep = config_tables; 479 pr_info(""); 480 for (i = 0; i < count; i++) { 481 efi_guid_t guid; 482 unsigned long table; 483 484 if (efi_enabled(EFI_64BIT)) { 485 u64 table64; 486 guid = ((efi_config_table_64_t *)tablep)->guid; 487 table64 = ((efi_config_table_64_t *)tablep)->table; 488 table = table64; 489 #ifndef CONFIG_64BIT 490 if (table64 >> 32) { 491 pr_cont("\n"); 492 pr_err("Table located above 4GB, disabling EFI.\n"); 493 return -EINVAL; 494 } 495 #endif 496 } else { 497 guid = ((efi_config_table_32_t *)tablep)->guid; 498 table = ((efi_config_table_32_t *)tablep)->table; 499 } 500 501 if (!match_config_table(&guid, table, common_tables)) 502 match_config_table(&guid, table, arch_tables); 503 504 tablep += sz; 505 } 506 pr_cont("\n"); 507 set_bit(EFI_CONFIG_TABLES, &efi.flags); 508 509 if (efi.rng_seed != EFI_INVALID_TABLE_ADDR) { 510 struct linux_efi_random_seed *seed; 511 u32 size = 0; 512 513 seed = early_memremap(efi.rng_seed, sizeof(*seed)); 514 if (seed != NULL) { 515 size = seed->size; 516 early_memunmap(seed, sizeof(*seed)); 517 } else { 518 pr_err("Could not map UEFI random seed!\n"); 519 } 520 if (size > 0) { 521 seed = early_memremap(efi.rng_seed, 522 sizeof(*seed) + size); 523 if (seed != NULL) { 524 add_device_randomness(seed->bits, seed->size); 525 early_memunmap(seed, sizeof(*seed) + size); 526 } else { 527 pr_err("Could not map UEFI random seed!\n"); 528 } 529 } 530 } 531 532 /* Parse the EFI Properties table if it exists */ 533 if (efi.properties_table != EFI_INVALID_TABLE_ADDR) { 534 efi_properties_table_t *tbl; 535 536 tbl = early_memremap(efi.properties_table, sizeof(*tbl)); 537 if (tbl == NULL) { 538 pr_err("Could not map Properties table!\n"); 539 return -ENOMEM; 540 } 541 542 if (tbl->memory_protection_attribute & 543 EFI_PROPERTIES_RUNTIME_MEMORY_PROTECTION_NON_EXECUTABLE_PE_DATA) 544 set_bit(EFI_NX_PE_DATA, &efi.flags); 545 546 early_memunmap(tbl, sizeof(*tbl)); 547 } 548 549 return 0; 550 } 551 552 int __init efi_config_init(efi_config_table_type_t *arch_tables) 553 { 554 void *config_tables; 555 int sz, ret; 556 557 if (efi_enabled(EFI_64BIT)) 558 sz = sizeof(efi_config_table_64_t); 559 else 560 sz = sizeof(efi_config_table_32_t); 561 562 /* 563 * Let's see what config tables the firmware passed to us. 564 */ 565 config_tables = early_memremap(efi.systab->tables, 566 efi.systab->nr_tables * sz); 567 if (config_tables == NULL) { 568 pr_err("Could not map Configuration table!\n"); 569 return -ENOMEM; 570 } 571 572 ret = efi_config_parse_tables(config_tables, efi.systab->nr_tables, sz, 573 arch_tables); 574 575 early_memunmap(config_tables, efi.systab->nr_tables * sz); 576 return ret; 577 } 578 579 #ifdef CONFIG_EFI_VARS_MODULE 580 static int __init efi_load_efivars(void) 581 { 582 struct platform_device *pdev; 583 584 if (!efi_enabled(EFI_RUNTIME_SERVICES)) 585 return 0; 586 587 pdev = platform_device_register_simple("efivars", 0, NULL, 0); 588 return IS_ERR(pdev) ? PTR_ERR(pdev) : 0; 589 } 590 device_initcall(efi_load_efivars); 591 #endif 592 593 #ifdef CONFIG_EFI_PARAMS_FROM_FDT 594 595 #define UEFI_PARAM(name, prop, field) \ 596 { \ 597 { name }, \ 598 { prop }, \ 599 offsetof(struct efi_fdt_params, field), \ 600 FIELD_SIZEOF(struct efi_fdt_params, field) \ 601 } 602 603 struct params { 604 const char name[32]; 605 const char propname[32]; 606 int offset; 607 int size; 608 }; 609 610 static __initdata struct params fdt_params[] = { 611 UEFI_PARAM("System Table", "linux,uefi-system-table", system_table), 612 UEFI_PARAM("MemMap Address", "linux,uefi-mmap-start", mmap), 613 UEFI_PARAM("MemMap Size", "linux,uefi-mmap-size", mmap_size), 614 UEFI_PARAM("MemMap Desc. Size", "linux,uefi-mmap-desc-size", desc_size), 615 UEFI_PARAM("MemMap Desc. Version", "linux,uefi-mmap-desc-ver", desc_ver) 616 }; 617 618 static __initdata struct params xen_fdt_params[] = { 619 UEFI_PARAM("System Table", "xen,uefi-system-table", system_table), 620 UEFI_PARAM("MemMap Address", "xen,uefi-mmap-start", mmap), 621 UEFI_PARAM("MemMap Size", "xen,uefi-mmap-size", mmap_size), 622 UEFI_PARAM("MemMap Desc. Size", "xen,uefi-mmap-desc-size", desc_size), 623 UEFI_PARAM("MemMap Desc. Version", "xen,uefi-mmap-desc-ver", desc_ver) 624 }; 625 626 #define EFI_FDT_PARAMS_SIZE ARRAY_SIZE(fdt_params) 627 628 static __initdata struct { 629 const char *uname; 630 const char *subnode; 631 struct params *params; 632 } dt_params[] = { 633 { "hypervisor", "uefi", xen_fdt_params }, 634 { "chosen", NULL, fdt_params }, 635 }; 636 637 struct param_info { 638 int found; 639 void *params; 640 const char *missing; 641 }; 642 643 static int __init __find_uefi_params(unsigned long node, 644 struct param_info *info, 645 struct params *params) 646 { 647 const void *prop; 648 void *dest; 649 u64 val; 650 int i, len; 651 652 for (i = 0; i < EFI_FDT_PARAMS_SIZE; i++) { 653 prop = of_get_flat_dt_prop(node, params[i].propname, &len); 654 if (!prop) { 655 info->missing = params[i].name; 656 return 0; 657 } 658 659 dest = info->params + params[i].offset; 660 info->found++; 661 662 val = of_read_number(prop, len / sizeof(u32)); 663 664 if (params[i].size == sizeof(u32)) 665 *(u32 *)dest = val; 666 else 667 *(u64 *)dest = val; 668 669 if (efi_enabled(EFI_DBG)) 670 pr_info(" %s: 0x%0*llx\n", params[i].name, 671 params[i].size * 2, val); 672 } 673 674 return 1; 675 } 676 677 static int __init fdt_find_uefi_params(unsigned long node, const char *uname, 678 int depth, void *data) 679 { 680 struct param_info *info = data; 681 int i; 682 683 for (i = 0; i < ARRAY_SIZE(dt_params); i++) { 684 const char *subnode = dt_params[i].subnode; 685 686 if (depth != 1 || strcmp(uname, dt_params[i].uname) != 0) { 687 info->missing = dt_params[i].params[0].name; 688 continue; 689 } 690 691 if (subnode) { 692 int err = of_get_flat_dt_subnode_by_name(node, subnode); 693 694 if (err < 0) 695 return 0; 696 697 node = err; 698 } 699 700 return __find_uefi_params(node, info, dt_params[i].params); 701 } 702 703 return 0; 704 } 705 706 int __init efi_get_fdt_params(struct efi_fdt_params *params) 707 { 708 struct param_info info; 709 int ret; 710 711 pr_info("Getting EFI parameters from FDT:\n"); 712 713 info.found = 0; 714 info.params = params; 715 716 ret = of_scan_flat_dt(fdt_find_uefi_params, &info); 717 if (!info.found) 718 pr_info("UEFI not found.\n"); 719 else if (!ret) 720 pr_err("Can't find '%s' in device tree!\n", 721 info.missing); 722 723 return ret; 724 } 725 #endif /* CONFIG_EFI_PARAMS_FROM_FDT */ 726 727 static __initdata char memory_type_name[][20] = { 728 "Reserved", 729 "Loader Code", 730 "Loader Data", 731 "Boot Code", 732 "Boot Data", 733 "Runtime Code", 734 "Runtime Data", 735 "Conventional Memory", 736 "Unusable Memory", 737 "ACPI Reclaim Memory", 738 "ACPI Memory NVS", 739 "Memory Mapped I/O", 740 "MMIO Port Space", 741 "PAL Code", 742 "Persistent Memory", 743 }; 744 745 char * __init efi_md_typeattr_format(char *buf, size_t size, 746 const efi_memory_desc_t *md) 747 { 748 char *pos; 749 int type_len; 750 u64 attr; 751 752 pos = buf; 753 if (md->type >= ARRAY_SIZE(memory_type_name)) 754 type_len = snprintf(pos, size, "[type=%u", md->type); 755 else 756 type_len = snprintf(pos, size, "[%-*s", 757 (int)(sizeof(memory_type_name[0]) - 1), 758 memory_type_name[md->type]); 759 if (type_len >= size) 760 return buf; 761 762 pos += type_len; 763 size -= type_len; 764 765 attr = md->attribute; 766 if (attr & ~(EFI_MEMORY_UC | EFI_MEMORY_WC | EFI_MEMORY_WT | 767 EFI_MEMORY_WB | EFI_MEMORY_UCE | EFI_MEMORY_RO | 768 EFI_MEMORY_WP | EFI_MEMORY_RP | EFI_MEMORY_XP | 769 EFI_MEMORY_NV | 770 EFI_MEMORY_RUNTIME | EFI_MEMORY_MORE_RELIABLE)) 771 snprintf(pos, size, "|attr=0x%016llx]", 772 (unsigned long long)attr); 773 else 774 snprintf(pos, size, 775 "|%3s|%2s|%2s|%2s|%2s|%2s|%2s|%3s|%2s|%2s|%2s|%2s]", 776 attr & EFI_MEMORY_RUNTIME ? "RUN" : "", 777 attr & EFI_MEMORY_MORE_RELIABLE ? "MR" : "", 778 attr & EFI_MEMORY_NV ? "NV" : "", 779 attr & EFI_MEMORY_XP ? "XP" : "", 780 attr & EFI_MEMORY_RP ? "RP" : "", 781 attr & EFI_MEMORY_WP ? "WP" : "", 782 attr & EFI_MEMORY_RO ? "RO" : "", 783 attr & EFI_MEMORY_UCE ? "UCE" : "", 784 attr & EFI_MEMORY_WB ? "WB" : "", 785 attr & EFI_MEMORY_WT ? "WT" : "", 786 attr & EFI_MEMORY_WC ? "WC" : "", 787 attr & EFI_MEMORY_UC ? "UC" : ""); 788 return buf; 789 } 790 791 /* 792 * efi_mem_attributes - lookup memmap attributes for physical address 793 * @phys_addr: the physical address to lookup 794 * 795 * Search in the EFI memory map for the region covering 796 * @phys_addr. Returns the EFI memory attributes if the region 797 * was found in the memory map, 0 otherwise. 798 * 799 * Despite being marked __weak, most architectures should *not* 800 * override this function. It is __weak solely for the benefit 801 * of ia64 which has a funky EFI memory map that doesn't work 802 * the same way as other architectures. 803 */ 804 u64 __weak efi_mem_attributes(unsigned long phys_addr) 805 { 806 efi_memory_desc_t *md; 807 808 if (!efi_enabled(EFI_MEMMAP)) 809 return 0; 810 811 for_each_efi_memory_desc(md) { 812 if ((md->phys_addr <= phys_addr) && 813 (phys_addr < (md->phys_addr + 814 (md->num_pages << EFI_PAGE_SHIFT)))) 815 return md->attribute; 816 } 817 return 0; 818 } 819 820 int efi_status_to_err(efi_status_t status) 821 { 822 int err; 823 824 switch (status) { 825 case EFI_SUCCESS: 826 err = 0; 827 break; 828 case EFI_INVALID_PARAMETER: 829 err = -EINVAL; 830 break; 831 case EFI_OUT_OF_RESOURCES: 832 err = -ENOSPC; 833 break; 834 case EFI_DEVICE_ERROR: 835 err = -EIO; 836 break; 837 case EFI_WRITE_PROTECTED: 838 err = -EROFS; 839 break; 840 case EFI_SECURITY_VIOLATION: 841 err = -EACCES; 842 break; 843 case EFI_NOT_FOUND: 844 err = -ENOENT; 845 break; 846 case EFI_ABORTED: 847 err = -EINTR; 848 break; 849 default: 850 err = -EINVAL; 851 } 852 853 return err; 854 } 855 856 #ifdef CONFIG_KEXEC 857 static int update_efi_random_seed(struct notifier_block *nb, 858 unsigned long code, void *unused) 859 { 860 struct linux_efi_random_seed *seed; 861 u32 size = 0; 862 863 if (!kexec_in_progress) 864 return NOTIFY_DONE; 865 866 seed = memremap(efi.rng_seed, sizeof(*seed), MEMREMAP_WB); 867 if (seed != NULL) { 868 size = min(seed->size, 32U); 869 memunmap(seed); 870 } else { 871 pr_err("Could not map UEFI random seed!\n"); 872 } 873 if (size > 0) { 874 seed = memremap(efi.rng_seed, sizeof(*seed) + size, 875 MEMREMAP_WB); 876 if (seed != NULL) { 877 seed->size = size; 878 get_random_bytes(seed->bits, seed->size); 879 memunmap(seed); 880 } else { 881 pr_err("Could not map UEFI random seed!\n"); 882 } 883 } 884 return NOTIFY_DONE; 885 } 886 887 static struct notifier_block efi_random_seed_nb = { 888 .notifier_call = update_efi_random_seed, 889 }; 890 891 static int register_update_efi_random_seed(void) 892 { 893 if (efi.rng_seed == EFI_INVALID_TABLE_ADDR) 894 return 0; 895 return register_reboot_notifier(&efi_random_seed_nb); 896 } 897 late_initcall(register_update_efi_random_seed); 898 #endif 899