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/platform_device.h> 27 28 #include <asm/early_ioremap.h> 29 30 struct efi __read_mostly efi = { 31 .mps = EFI_INVALID_TABLE_ADDR, 32 .acpi = EFI_INVALID_TABLE_ADDR, 33 .acpi20 = EFI_INVALID_TABLE_ADDR, 34 .smbios = EFI_INVALID_TABLE_ADDR, 35 .smbios3 = EFI_INVALID_TABLE_ADDR, 36 .sal_systab = EFI_INVALID_TABLE_ADDR, 37 .boot_info = EFI_INVALID_TABLE_ADDR, 38 .hcdp = EFI_INVALID_TABLE_ADDR, 39 .uga = EFI_INVALID_TABLE_ADDR, 40 .uv_systab = EFI_INVALID_TABLE_ADDR, 41 .fw_vendor = EFI_INVALID_TABLE_ADDR, 42 .runtime = EFI_INVALID_TABLE_ADDR, 43 .config_table = EFI_INVALID_TABLE_ADDR, 44 .esrt = EFI_INVALID_TABLE_ADDR, 45 .properties_table = EFI_INVALID_TABLE_ADDR, 46 }; 47 EXPORT_SYMBOL(efi); 48 49 static bool disable_runtime; 50 static int __init setup_noefi(char *arg) 51 { 52 disable_runtime = true; 53 return 0; 54 } 55 early_param("noefi", setup_noefi); 56 57 bool efi_runtime_disabled(void) 58 { 59 return disable_runtime; 60 } 61 62 static int __init parse_efi_cmdline(char *str) 63 { 64 if (!str) { 65 pr_warn("need at least one option\n"); 66 return -EINVAL; 67 } 68 69 if (parse_option_str(str, "debug")) 70 set_bit(EFI_DBG, &efi.flags); 71 72 if (parse_option_str(str, "noruntime")) 73 disable_runtime = true; 74 75 return 0; 76 } 77 early_param("efi", parse_efi_cmdline); 78 79 struct kobject *efi_kobj; 80 81 /* 82 * Let's not leave out systab information that snuck into 83 * the efivars driver 84 */ 85 static ssize_t systab_show(struct kobject *kobj, 86 struct kobj_attribute *attr, char *buf) 87 { 88 char *str = buf; 89 90 if (!kobj || !buf) 91 return -EINVAL; 92 93 if (efi.mps != EFI_INVALID_TABLE_ADDR) 94 str += sprintf(str, "MPS=0x%lx\n", efi.mps); 95 if (efi.acpi20 != EFI_INVALID_TABLE_ADDR) 96 str += sprintf(str, "ACPI20=0x%lx\n", efi.acpi20); 97 if (efi.acpi != EFI_INVALID_TABLE_ADDR) 98 str += sprintf(str, "ACPI=0x%lx\n", efi.acpi); 99 /* 100 * If both SMBIOS and SMBIOS3 entry points are implemented, the 101 * SMBIOS3 entry point shall be preferred, so we list it first to 102 * let applications stop parsing after the first match. 103 */ 104 if (efi.smbios3 != EFI_INVALID_TABLE_ADDR) 105 str += sprintf(str, "SMBIOS3=0x%lx\n", efi.smbios3); 106 if (efi.smbios != EFI_INVALID_TABLE_ADDR) 107 str += sprintf(str, "SMBIOS=0x%lx\n", efi.smbios); 108 if (efi.hcdp != EFI_INVALID_TABLE_ADDR) 109 str += sprintf(str, "HCDP=0x%lx\n", efi.hcdp); 110 if (efi.boot_info != EFI_INVALID_TABLE_ADDR) 111 str += sprintf(str, "BOOTINFO=0x%lx\n", efi.boot_info); 112 if (efi.uga != EFI_INVALID_TABLE_ADDR) 113 str += sprintf(str, "UGA=0x%lx\n", efi.uga); 114 115 return str - buf; 116 } 117 118 static struct kobj_attribute efi_attr_systab = 119 __ATTR(systab, 0400, systab_show, NULL); 120 121 #define EFI_FIELD(var) efi.var 122 123 #define EFI_ATTR_SHOW(name) \ 124 static ssize_t name##_show(struct kobject *kobj, \ 125 struct kobj_attribute *attr, char *buf) \ 126 { \ 127 return sprintf(buf, "0x%lx\n", EFI_FIELD(name)); \ 128 } 129 130 EFI_ATTR_SHOW(fw_vendor); 131 EFI_ATTR_SHOW(runtime); 132 EFI_ATTR_SHOW(config_table); 133 134 static ssize_t fw_platform_size_show(struct kobject *kobj, 135 struct kobj_attribute *attr, char *buf) 136 { 137 return sprintf(buf, "%d\n", efi_enabled(EFI_64BIT) ? 64 : 32); 138 } 139 140 static struct kobj_attribute efi_attr_fw_vendor = __ATTR_RO(fw_vendor); 141 static struct kobj_attribute efi_attr_runtime = __ATTR_RO(runtime); 142 static struct kobj_attribute efi_attr_config_table = __ATTR_RO(config_table); 143 static struct kobj_attribute efi_attr_fw_platform_size = 144 __ATTR_RO(fw_platform_size); 145 146 static struct attribute *efi_subsys_attrs[] = { 147 &efi_attr_systab.attr, 148 &efi_attr_fw_vendor.attr, 149 &efi_attr_runtime.attr, 150 &efi_attr_config_table.attr, 151 &efi_attr_fw_platform_size.attr, 152 NULL, 153 }; 154 155 static umode_t efi_attr_is_visible(struct kobject *kobj, 156 struct attribute *attr, int n) 157 { 158 if (attr == &efi_attr_fw_vendor.attr) { 159 if (efi_enabled(EFI_PARAVIRT) || 160 efi.fw_vendor == EFI_INVALID_TABLE_ADDR) 161 return 0; 162 } else if (attr == &efi_attr_runtime.attr) { 163 if (efi.runtime == EFI_INVALID_TABLE_ADDR) 164 return 0; 165 } else if (attr == &efi_attr_config_table.attr) { 166 if (efi.config_table == EFI_INVALID_TABLE_ADDR) 167 return 0; 168 } 169 170 return attr->mode; 171 } 172 173 static struct attribute_group efi_subsys_attr_group = { 174 .attrs = efi_subsys_attrs, 175 .is_visible = efi_attr_is_visible, 176 }; 177 178 static struct efivars generic_efivars; 179 static struct efivar_operations generic_ops; 180 181 static int generic_ops_register(void) 182 { 183 generic_ops.get_variable = efi.get_variable; 184 generic_ops.set_variable = efi.set_variable; 185 generic_ops.set_variable_nonblocking = efi.set_variable_nonblocking; 186 generic_ops.get_next_variable = efi.get_next_variable; 187 generic_ops.query_variable_store = efi_query_variable_store; 188 189 return efivars_register(&generic_efivars, &generic_ops, efi_kobj); 190 } 191 192 static void generic_ops_unregister(void) 193 { 194 efivars_unregister(&generic_efivars); 195 } 196 197 /* 198 * We register the efi subsystem with the firmware subsystem and the 199 * efivars subsystem with the efi subsystem, if the system was booted with 200 * EFI. 201 */ 202 static int __init efisubsys_init(void) 203 { 204 int error; 205 206 if (!efi_enabled(EFI_BOOT)) 207 return 0; 208 209 /* We register the efi directory at /sys/firmware/efi */ 210 efi_kobj = kobject_create_and_add("efi", firmware_kobj); 211 if (!efi_kobj) { 212 pr_err("efi: Firmware registration failed.\n"); 213 return -ENOMEM; 214 } 215 216 error = generic_ops_register(); 217 if (error) 218 goto err_put; 219 220 error = sysfs_create_group(efi_kobj, &efi_subsys_attr_group); 221 if (error) { 222 pr_err("efi: Sysfs attribute export failed with error %d.\n", 223 error); 224 goto err_unregister; 225 } 226 227 error = efi_runtime_map_init(efi_kobj); 228 if (error) 229 goto err_remove_group; 230 231 /* and the standard mountpoint for efivarfs */ 232 error = sysfs_create_mount_point(efi_kobj, "efivars"); 233 if (error) { 234 pr_err("efivars: Subsystem registration failed.\n"); 235 goto err_remove_group; 236 } 237 238 return 0; 239 240 err_remove_group: 241 sysfs_remove_group(efi_kobj, &efi_subsys_attr_group); 242 err_unregister: 243 generic_ops_unregister(); 244 err_put: 245 kobject_put(efi_kobj); 246 return error; 247 } 248 249 subsys_initcall(efisubsys_init); 250 251 /* 252 * Find the efi memory descriptor for a given physical address. Given a 253 * physicall address, determine if it exists within an EFI Memory Map entry, 254 * and if so, populate the supplied memory descriptor with the appropriate 255 * data. 256 */ 257 int __init efi_mem_desc_lookup(u64 phys_addr, efi_memory_desc_t *out_md) 258 { 259 struct efi_memory_map *map = efi.memmap; 260 phys_addr_t p, e; 261 262 if (!efi_enabled(EFI_MEMMAP)) { 263 pr_err_once("EFI_MEMMAP is not enabled.\n"); 264 return -EINVAL; 265 } 266 267 if (!map) { 268 pr_err_once("efi.memmap is not set.\n"); 269 return -EINVAL; 270 } 271 if (!out_md) { 272 pr_err_once("out_md is null.\n"); 273 return -EINVAL; 274 } 275 if (WARN_ON_ONCE(!map->phys_map)) 276 return -EINVAL; 277 if (WARN_ON_ONCE(map->nr_map == 0) || WARN_ON_ONCE(map->desc_size == 0)) 278 return -EINVAL; 279 280 e = map->phys_map + map->nr_map * map->desc_size; 281 for (p = map->phys_map; p < e; p += map->desc_size) { 282 efi_memory_desc_t *md; 283 u64 size; 284 u64 end; 285 286 /* 287 * If a driver calls this after efi_free_boot_services, 288 * ->map will be NULL, and the target may also not be mapped. 289 * So just always get our own virtual map on the CPU. 290 * 291 */ 292 md = early_memremap(p, sizeof (*md)); 293 if (!md) { 294 pr_err_once("early_memremap(%pa, %zu) failed.\n", 295 &p, sizeof (*md)); 296 return -ENOMEM; 297 } 298 299 if (!(md->attribute & EFI_MEMORY_RUNTIME) && 300 md->type != EFI_BOOT_SERVICES_DATA && 301 md->type != EFI_RUNTIME_SERVICES_DATA) { 302 early_memunmap(md, sizeof (*md)); 303 continue; 304 } 305 306 size = md->num_pages << EFI_PAGE_SHIFT; 307 end = md->phys_addr + size; 308 if (phys_addr >= md->phys_addr && phys_addr < end) { 309 memcpy(out_md, md, sizeof(*out_md)); 310 early_memunmap(md, sizeof (*md)); 311 return 0; 312 } 313 314 early_memunmap(md, sizeof (*md)); 315 } 316 pr_err_once("requested map not found.\n"); 317 return -ENOENT; 318 } 319 320 /* 321 * Calculate the highest address of an efi memory descriptor. 322 */ 323 u64 __init efi_mem_desc_end(efi_memory_desc_t *md) 324 { 325 u64 size = md->num_pages << EFI_PAGE_SHIFT; 326 u64 end = md->phys_addr + size; 327 return end; 328 } 329 330 static __initdata efi_config_table_type_t common_tables[] = { 331 {ACPI_20_TABLE_GUID, "ACPI 2.0", &efi.acpi20}, 332 {ACPI_TABLE_GUID, "ACPI", &efi.acpi}, 333 {HCDP_TABLE_GUID, "HCDP", &efi.hcdp}, 334 {MPS_TABLE_GUID, "MPS", &efi.mps}, 335 {SAL_SYSTEM_TABLE_GUID, "SALsystab", &efi.sal_systab}, 336 {SMBIOS_TABLE_GUID, "SMBIOS", &efi.smbios}, 337 {SMBIOS3_TABLE_GUID, "SMBIOS 3.0", &efi.smbios3}, 338 {UGA_IO_PROTOCOL_GUID, "UGA", &efi.uga}, 339 {EFI_SYSTEM_RESOURCE_TABLE_GUID, "ESRT", &efi.esrt}, 340 {EFI_PROPERTIES_TABLE_GUID, "PROP", &efi.properties_table}, 341 {NULL_GUID, NULL, NULL}, 342 }; 343 344 static __init int match_config_table(efi_guid_t *guid, 345 unsigned long table, 346 efi_config_table_type_t *table_types) 347 { 348 int i; 349 350 if (table_types) { 351 for (i = 0; efi_guidcmp(table_types[i].guid, NULL_GUID); i++) { 352 if (!efi_guidcmp(*guid, table_types[i].guid)) { 353 *(table_types[i].ptr) = table; 354 pr_cont(" %s=0x%lx ", 355 table_types[i].name, table); 356 return 1; 357 } 358 } 359 } 360 361 return 0; 362 } 363 364 int __init efi_config_parse_tables(void *config_tables, int count, int sz, 365 efi_config_table_type_t *arch_tables) 366 { 367 void *tablep; 368 int i; 369 370 tablep = config_tables; 371 pr_info(""); 372 for (i = 0; i < count; i++) { 373 efi_guid_t guid; 374 unsigned long table; 375 376 if (efi_enabled(EFI_64BIT)) { 377 u64 table64; 378 guid = ((efi_config_table_64_t *)tablep)->guid; 379 table64 = ((efi_config_table_64_t *)tablep)->table; 380 table = table64; 381 #ifndef CONFIG_64BIT 382 if (table64 >> 32) { 383 pr_cont("\n"); 384 pr_err("Table located above 4GB, disabling EFI.\n"); 385 return -EINVAL; 386 } 387 #endif 388 } else { 389 guid = ((efi_config_table_32_t *)tablep)->guid; 390 table = ((efi_config_table_32_t *)tablep)->table; 391 } 392 393 if (!match_config_table(&guid, table, common_tables)) 394 match_config_table(&guid, table, arch_tables); 395 396 tablep += sz; 397 } 398 pr_cont("\n"); 399 set_bit(EFI_CONFIG_TABLES, &efi.flags); 400 401 /* Parse the EFI Properties table if it exists */ 402 if (efi.properties_table != EFI_INVALID_TABLE_ADDR) { 403 efi_properties_table_t *tbl; 404 405 tbl = early_memremap(efi.properties_table, sizeof(*tbl)); 406 if (tbl == NULL) { 407 pr_err("Could not map Properties table!\n"); 408 return -ENOMEM; 409 } 410 411 if (tbl->memory_protection_attribute & 412 EFI_PROPERTIES_RUNTIME_MEMORY_PROTECTION_NON_EXECUTABLE_PE_DATA) 413 set_bit(EFI_NX_PE_DATA, &efi.flags); 414 415 early_memunmap(tbl, sizeof(*tbl)); 416 } 417 418 return 0; 419 } 420 421 int __init efi_config_init(efi_config_table_type_t *arch_tables) 422 { 423 void *config_tables; 424 int sz, ret; 425 426 if (efi_enabled(EFI_64BIT)) 427 sz = sizeof(efi_config_table_64_t); 428 else 429 sz = sizeof(efi_config_table_32_t); 430 431 /* 432 * Let's see what config tables the firmware passed to us. 433 */ 434 config_tables = early_memremap(efi.systab->tables, 435 efi.systab->nr_tables * sz); 436 if (config_tables == NULL) { 437 pr_err("Could not map Configuration table!\n"); 438 return -ENOMEM; 439 } 440 441 ret = efi_config_parse_tables(config_tables, efi.systab->nr_tables, sz, 442 arch_tables); 443 444 early_memunmap(config_tables, efi.systab->nr_tables * sz); 445 return ret; 446 } 447 448 #ifdef CONFIG_EFI_VARS_MODULE 449 static int __init efi_load_efivars(void) 450 { 451 struct platform_device *pdev; 452 453 if (!efi_enabled(EFI_RUNTIME_SERVICES)) 454 return 0; 455 456 pdev = platform_device_register_simple("efivars", 0, NULL, 0); 457 return IS_ERR(pdev) ? PTR_ERR(pdev) : 0; 458 } 459 device_initcall(efi_load_efivars); 460 #endif 461 462 #ifdef CONFIG_EFI_PARAMS_FROM_FDT 463 464 #define UEFI_PARAM(name, prop, field) \ 465 { \ 466 { name }, \ 467 { prop }, \ 468 offsetof(struct efi_fdt_params, field), \ 469 FIELD_SIZEOF(struct efi_fdt_params, field) \ 470 } 471 472 static __initdata struct { 473 const char name[32]; 474 const char propname[32]; 475 int offset; 476 int size; 477 } dt_params[] = { 478 UEFI_PARAM("System Table", "linux,uefi-system-table", system_table), 479 UEFI_PARAM("MemMap Address", "linux,uefi-mmap-start", mmap), 480 UEFI_PARAM("MemMap Size", "linux,uefi-mmap-size", mmap_size), 481 UEFI_PARAM("MemMap Desc. Size", "linux,uefi-mmap-desc-size", desc_size), 482 UEFI_PARAM("MemMap Desc. Version", "linux,uefi-mmap-desc-ver", desc_ver) 483 }; 484 485 struct param_info { 486 int found; 487 void *params; 488 }; 489 490 static int __init fdt_find_uefi_params(unsigned long node, const char *uname, 491 int depth, void *data) 492 { 493 struct param_info *info = data; 494 const void *prop; 495 void *dest; 496 u64 val; 497 int i, len; 498 499 if (depth != 1 || strcmp(uname, "chosen") != 0) 500 return 0; 501 502 for (i = 0; i < ARRAY_SIZE(dt_params); i++) { 503 prop = of_get_flat_dt_prop(node, dt_params[i].propname, &len); 504 if (!prop) 505 return 0; 506 dest = info->params + dt_params[i].offset; 507 info->found++; 508 509 val = of_read_number(prop, len / sizeof(u32)); 510 511 if (dt_params[i].size == sizeof(u32)) 512 *(u32 *)dest = val; 513 else 514 *(u64 *)dest = val; 515 516 if (efi_enabled(EFI_DBG)) 517 pr_info(" %s: 0x%0*llx\n", dt_params[i].name, 518 dt_params[i].size * 2, val); 519 } 520 return 1; 521 } 522 523 int __init efi_get_fdt_params(struct efi_fdt_params *params) 524 { 525 struct param_info info; 526 int ret; 527 528 pr_info("Getting EFI parameters from FDT:\n"); 529 530 info.found = 0; 531 info.params = params; 532 533 ret = of_scan_flat_dt(fdt_find_uefi_params, &info); 534 if (!info.found) 535 pr_info("UEFI not found.\n"); 536 else if (!ret) 537 pr_err("Can't find '%s' in device tree!\n", 538 dt_params[info.found].name); 539 540 return ret; 541 } 542 #endif /* CONFIG_EFI_PARAMS_FROM_FDT */ 543 544 static __initdata char memory_type_name[][20] = { 545 "Reserved", 546 "Loader Code", 547 "Loader Data", 548 "Boot Code", 549 "Boot Data", 550 "Runtime Code", 551 "Runtime Data", 552 "Conventional Memory", 553 "Unusable Memory", 554 "ACPI Reclaim Memory", 555 "ACPI Memory NVS", 556 "Memory Mapped I/O", 557 "MMIO Port Space", 558 "PAL Code", 559 "Persistent Memory", 560 }; 561 562 char * __init efi_md_typeattr_format(char *buf, size_t size, 563 const efi_memory_desc_t *md) 564 { 565 char *pos; 566 int type_len; 567 u64 attr; 568 569 pos = buf; 570 if (md->type >= ARRAY_SIZE(memory_type_name)) 571 type_len = snprintf(pos, size, "[type=%u", md->type); 572 else 573 type_len = snprintf(pos, size, "[%-*s", 574 (int)(sizeof(memory_type_name[0]) - 1), 575 memory_type_name[md->type]); 576 if (type_len >= size) 577 return buf; 578 579 pos += type_len; 580 size -= type_len; 581 582 attr = md->attribute; 583 if (attr & ~(EFI_MEMORY_UC | EFI_MEMORY_WC | EFI_MEMORY_WT | 584 EFI_MEMORY_WB | EFI_MEMORY_UCE | EFI_MEMORY_RO | 585 EFI_MEMORY_WP | EFI_MEMORY_RP | EFI_MEMORY_XP | 586 EFI_MEMORY_NV | 587 EFI_MEMORY_RUNTIME | EFI_MEMORY_MORE_RELIABLE)) 588 snprintf(pos, size, "|attr=0x%016llx]", 589 (unsigned long long)attr); 590 else 591 snprintf(pos, size, 592 "|%3s|%2s|%2s|%2s|%2s|%2s|%2s|%3s|%2s|%2s|%2s|%2s]", 593 attr & EFI_MEMORY_RUNTIME ? "RUN" : "", 594 attr & EFI_MEMORY_MORE_RELIABLE ? "MR" : "", 595 attr & EFI_MEMORY_NV ? "NV" : "", 596 attr & EFI_MEMORY_XP ? "XP" : "", 597 attr & EFI_MEMORY_RP ? "RP" : "", 598 attr & EFI_MEMORY_WP ? "WP" : "", 599 attr & EFI_MEMORY_RO ? "RO" : "", 600 attr & EFI_MEMORY_UCE ? "UCE" : "", 601 attr & EFI_MEMORY_WB ? "WB" : "", 602 attr & EFI_MEMORY_WT ? "WT" : "", 603 attr & EFI_MEMORY_WC ? "WC" : "", 604 attr & EFI_MEMORY_UC ? "UC" : ""); 605 return buf; 606 } 607 608 /* 609 * efi_mem_attributes - lookup memmap attributes for physical address 610 * @phys_addr: the physical address to lookup 611 * 612 * Search in the EFI memory map for the region covering 613 * @phys_addr. Returns the EFI memory attributes if the region 614 * was found in the memory map, 0 otherwise. 615 * 616 * Despite being marked __weak, most architectures should *not* 617 * override this function. It is __weak solely for the benefit 618 * of ia64 which has a funky EFI memory map that doesn't work 619 * the same way as other architectures. 620 */ 621 u64 __weak efi_mem_attributes(unsigned long phys_addr) 622 { 623 struct efi_memory_map *map; 624 efi_memory_desc_t *md; 625 void *p; 626 627 if (!efi_enabled(EFI_MEMMAP)) 628 return 0; 629 630 map = efi.memmap; 631 for (p = map->map; p < map->map_end; p += map->desc_size) { 632 md = p; 633 if ((md->phys_addr <= phys_addr) && 634 (phys_addr < (md->phys_addr + 635 (md->num_pages << EFI_PAGE_SHIFT)))) 636 return md->attribute; 637 } 638 return 0; 639 } 640