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 struct efi __read_mostly efi = { 29 .mps = EFI_INVALID_TABLE_ADDR, 30 .acpi = EFI_INVALID_TABLE_ADDR, 31 .acpi20 = EFI_INVALID_TABLE_ADDR, 32 .smbios = EFI_INVALID_TABLE_ADDR, 33 .smbios3 = EFI_INVALID_TABLE_ADDR, 34 .sal_systab = EFI_INVALID_TABLE_ADDR, 35 .boot_info = EFI_INVALID_TABLE_ADDR, 36 .hcdp = EFI_INVALID_TABLE_ADDR, 37 .uga = EFI_INVALID_TABLE_ADDR, 38 .uv_systab = EFI_INVALID_TABLE_ADDR, 39 .fw_vendor = EFI_INVALID_TABLE_ADDR, 40 .runtime = EFI_INVALID_TABLE_ADDR, 41 .config_table = EFI_INVALID_TABLE_ADDR, 42 }; 43 EXPORT_SYMBOL(efi); 44 45 static bool disable_runtime; 46 static int __init setup_noefi(char *arg) 47 { 48 disable_runtime = true; 49 return 0; 50 } 51 early_param("noefi", setup_noefi); 52 53 bool efi_runtime_disabled(void) 54 { 55 return disable_runtime; 56 } 57 58 static int __init parse_efi_cmdline(char *str) 59 { 60 if (parse_option_str(str, "noruntime")) 61 disable_runtime = true; 62 63 return 0; 64 } 65 early_param("efi", parse_efi_cmdline); 66 67 static struct kobject *efi_kobj; 68 static struct kobject *efivars_kobj; 69 70 /* 71 * Let's not leave out systab information that snuck into 72 * the efivars driver 73 */ 74 static ssize_t systab_show(struct kobject *kobj, 75 struct kobj_attribute *attr, char *buf) 76 { 77 char *str = buf; 78 79 if (!kobj || !buf) 80 return -EINVAL; 81 82 if (efi.mps != EFI_INVALID_TABLE_ADDR) 83 str += sprintf(str, "MPS=0x%lx\n", efi.mps); 84 if (efi.acpi20 != EFI_INVALID_TABLE_ADDR) 85 str += sprintf(str, "ACPI20=0x%lx\n", efi.acpi20); 86 if (efi.acpi != EFI_INVALID_TABLE_ADDR) 87 str += sprintf(str, "ACPI=0x%lx\n", efi.acpi); 88 if (efi.smbios != EFI_INVALID_TABLE_ADDR) 89 str += sprintf(str, "SMBIOS=0x%lx\n", efi.smbios); 90 if (efi.smbios3 != EFI_INVALID_TABLE_ADDR) 91 str += sprintf(str, "SMBIOS3=0x%lx\n", efi.smbios3); 92 if (efi.hcdp != EFI_INVALID_TABLE_ADDR) 93 str += sprintf(str, "HCDP=0x%lx\n", efi.hcdp); 94 if (efi.boot_info != EFI_INVALID_TABLE_ADDR) 95 str += sprintf(str, "BOOTINFO=0x%lx\n", efi.boot_info); 96 if (efi.uga != EFI_INVALID_TABLE_ADDR) 97 str += sprintf(str, "UGA=0x%lx\n", efi.uga); 98 99 return str - buf; 100 } 101 102 static struct kobj_attribute efi_attr_systab = 103 __ATTR(systab, 0400, systab_show, NULL); 104 105 #define EFI_FIELD(var) efi.var 106 107 #define EFI_ATTR_SHOW(name) \ 108 static ssize_t name##_show(struct kobject *kobj, \ 109 struct kobj_attribute *attr, char *buf) \ 110 { \ 111 return sprintf(buf, "0x%lx\n", EFI_FIELD(name)); \ 112 } 113 114 EFI_ATTR_SHOW(fw_vendor); 115 EFI_ATTR_SHOW(runtime); 116 EFI_ATTR_SHOW(config_table); 117 118 static ssize_t fw_platform_size_show(struct kobject *kobj, 119 struct kobj_attribute *attr, char *buf) 120 { 121 return sprintf(buf, "%d\n", efi_enabled(EFI_64BIT) ? 64 : 32); 122 } 123 124 static struct kobj_attribute efi_attr_fw_vendor = __ATTR_RO(fw_vendor); 125 static struct kobj_attribute efi_attr_runtime = __ATTR_RO(runtime); 126 static struct kobj_attribute efi_attr_config_table = __ATTR_RO(config_table); 127 static struct kobj_attribute efi_attr_fw_platform_size = 128 __ATTR_RO(fw_platform_size); 129 130 static struct attribute *efi_subsys_attrs[] = { 131 &efi_attr_systab.attr, 132 &efi_attr_fw_vendor.attr, 133 &efi_attr_runtime.attr, 134 &efi_attr_config_table.attr, 135 &efi_attr_fw_platform_size.attr, 136 NULL, 137 }; 138 139 static umode_t efi_attr_is_visible(struct kobject *kobj, 140 struct attribute *attr, int n) 141 { 142 if (attr == &efi_attr_fw_vendor.attr) { 143 if (efi_enabled(EFI_PARAVIRT) || 144 efi.fw_vendor == EFI_INVALID_TABLE_ADDR) 145 return 0; 146 } else if (attr == &efi_attr_runtime.attr) { 147 if (efi.runtime == EFI_INVALID_TABLE_ADDR) 148 return 0; 149 } else if (attr == &efi_attr_config_table.attr) { 150 if (efi.config_table == EFI_INVALID_TABLE_ADDR) 151 return 0; 152 } 153 154 return attr->mode; 155 } 156 157 static struct attribute_group efi_subsys_attr_group = { 158 .attrs = efi_subsys_attrs, 159 .is_visible = efi_attr_is_visible, 160 }; 161 162 static struct efivars generic_efivars; 163 static struct efivar_operations generic_ops; 164 165 static int generic_ops_register(void) 166 { 167 generic_ops.get_variable = efi.get_variable; 168 generic_ops.set_variable = efi.set_variable; 169 generic_ops.get_next_variable = efi.get_next_variable; 170 generic_ops.query_variable_store = efi_query_variable_store; 171 172 return efivars_register(&generic_efivars, &generic_ops, efi_kobj); 173 } 174 175 static void generic_ops_unregister(void) 176 { 177 efivars_unregister(&generic_efivars); 178 } 179 180 /* 181 * We register the efi subsystem with the firmware subsystem and the 182 * efivars subsystem with the efi subsystem, if the system was booted with 183 * EFI. 184 */ 185 static int __init efisubsys_init(void) 186 { 187 int error; 188 189 if (!efi_enabled(EFI_BOOT)) 190 return 0; 191 192 /* We register the efi directory at /sys/firmware/efi */ 193 efi_kobj = kobject_create_and_add("efi", firmware_kobj); 194 if (!efi_kobj) { 195 pr_err("efi: Firmware registration failed.\n"); 196 return -ENOMEM; 197 } 198 199 error = generic_ops_register(); 200 if (error) 201 goto err_put; 202 203 error = sysfs_create_group(efi_kobj, &efi_subsys_attr_group); 204 if (error) { 205 pr_err("efi: Sysfs attribute export failed with error %d.\n", 206 error); 207 goto err_unregister; 208 } 209 210 error = efi_runtime_map_init(efi_kobj); 211 if (error) 212 goto err_remove_group; 213 214 /* and the standard mountpoint for efivarfs */ 215 efivars_kobj = kobject_create_and_add("efivars", efi_kobj); 216 if (!efivars_kobj) { 217 pr_err("efivars: Subsystem registration failed.\n"); 218 error = -ENOMEM; 219 goto err_remove_group; 220 } 221 222 return 0; 223 224 err_remove_group: 225 sysfs_remove_group(efi_kobj, &efi_subsys_attr_group); 226 err_unregister: 227 generic_ops_unregister(); 228 err_put: 229 kobject_put(efi_kobj); 230 return error; 231 } 232 233 subsys_initcall(efisubsys_init); 234 235 236 /* 237 * We can't ioremap data in EFI boot services RAM, because we've already mapped 238 * it as RAM. So, look it up in the existing EFI memory map instead. Only 239 * callable after efi_enter_virtual_mode and before efi_free_boot_services. 240 */ 241 void __iomem *efi_lookup_mapped_addr(u64 phys_addr) 242 { 243 struct efi_memory_map *map; 244 void *p; 245 map = efi.memmap; 246 if (!map) 247 return NULL; 248 if (WARN_ON(!map->map)) 249 return NULL; 250 for (p = map->map; p < map->map_end; p += map->desc_size) { 251 efi_memory_desc_t *md = p; 252 u64 size = md->num_pages << EFI_PAGE_SHIFT; 253 u64 end = md->phys_addr + size; 254 if (!(md->attribute & EFI_MEMORY_RUNTIME) && 255 md->type != EFI_BOOT_SERVICES_CODE && 256 md->type != EFI_BOOT_SERVICES_DATA) 257 continue; 258 if (!md->virt_addr) 259 continue; 260 if (phys_addr >= md->phys_addr && phys_addr < end) { 261 phys_addr += md->virt_addr - md->phys_addr; 262 return (__force void __iomem *)(unsigned long)phys_addr; 263 } 264 } 265 return NULL; 266 } 267 268 static __initdata efi_config_table_type_t common_tables[] = { 269 {ACPI_20_TABLE_GUID, "ACPI 2.0", &efi.acpi20}, 270 {ACPI_TABLE_GUID, "ACPI", &efi.acpi}, 271 {HCDP_TABLE_GUID, "HCDP", &efi.hcdp}, 272 {MPS_TABLE_GUID, "MPS", &efi.mps}, 273 {SAL_SYSTEM_TABLE_GUID, "SALsystab", &efi.sal_systab}, 274 {SMBIOS_TABLE_GUID, "SMBIOS", &efi.smbios}, 275 {SMBIOS3_TABLE_GUID, "SMBIOS 3.0", &efi.smbios3}, 276 {UGA_IO_PROTOCOL_GUID, "UGA", &efi.uga}, 277 {NULL_GUID, NULL, NULL}, 278 }; 279 280 static __init int match_config_table(efi_guid_t *guid, 281 unsigned long table, 282 efi_config_table_type_t *table_types) 283 { 284 int i; 285 286 if (table_types) { 287 for (i = 0; efi_guidcmp(table_types[i].guid, NULL_GUID); i++) { 288 if (!efi_guidcmp(*guid, table_types[i].guid)) { 289 *(table_types[i].ptr) = table; 290 pr_cont(" %s=0x%lx ", 291 table_types[i].name, table); 292 return 1; 293 } 294 } 295 } 296 297 return 0; 298 } 299 300 int __init efi_config_parse_tables(void *config_tables, int count, int sz, 301 efi_config_table_type_t *arch_tables) 302 { 303 void *tablep; 304 int i; 305 306 tablep = config_tables; 307 pr_info(""); 308 for (i = 0; i < count; i++) { 309 efi_guid_t guid; 310 unsigned long table; 311 312 if (efi_enabled(EFI_64BIT)) { 313 u64 table64; 314 guid = ((efi_config_table_64_t *)tablep)->guid; 315 table64 = ((efi_config_table_64_t *)tablep)->table; 316 table = table64; 317 #ifndef CONFIG_64BIT 318 if (table64 >> 32) { 319 pr_cont("\n"); 320 pr_err("Table located above 4GB, disabling EFI.\n"); 321 return -EINVAL; 322 } 323 #endif 324 } else { 325 guid = ((efi_config_table_32_t *)tablep)->guid; 326 table = ((efi_config_table_32_t *)tablep)->table; 327 } 328 329 if (!match_config_table(&guid, table, common_tables)) 330 match_config_table(&guid, table, arch_tables); 331 332 tablep += sz; 333 } 334 pr_cont("\n"); 335 set_bit(EFI_CONFIG_TABLES, &efi.flags); 336 return 0; 337 } 338 339 int __init efi_config_init(efi_config_table_type_t *arch_tables) 340 { 341 void *config_tables; 342 int sz, ret; 343 344 if (efi_enabled(EFI_64BIT)) 345 sz = sizeof(efi_config_table_64_t); 346 else 347 sz = sizeof(efi_config_table_32_t); 348 349 /* 350 * Let's see what config tables the firmware passed to us. 351 */ 352 config_tables = early_memremap(efi.systab->tables, 353 efi.systab->nr_tables * sz); 354 if (config_tables == NULL) { 355 pr_err("Could not map Configuration table!\n"); 356 return -ENOMEM; 357 } 358 359 ret = efi_config_parse_tables(config_tables, efi.systab->nr_tables, sz, 360 arch_tables); 361 362 early_memunmap(config_tables, efi.systab->nr_tables * sz); 363 return ret; 364 } 365 366 #ifdef CONFIG_EFI_VARS_MODULE 367 static int __init efi_load_efivars(void) 368 { 369 struct platform_device *pdev; 370 371 if (!efi_enabled(EFI_RUNTIME_SERVICES)) 372 return 0; 373 374 pdev = platform_device_register_simple("efivars", 0, NULL, 0); 375 return IS_ERR(pdev) ? PTR_ERR(pdev) : 0; 376 } 377 device_initcall(efi_load_efivars); 378 #endif 379 380 #ifdef CONFIG_EFI_PARAMS_FROM_FDT 381 382 #define UEFI_PARAM(name, prop, field) \ 383 { \ 384 { name }, \ 385 { prop }, \ 386 offsetof(struct efi_fdt_params, field), \ 387 FIELD_SIZEOF(struct efi_fdt_params, field) \ 388 } 389 390 static __initdata struct { 391 const char name[32]; 392 const char propname[32]; 393 int offset; 394 int size; 395 } dt_params[] = { 396 UEFI_PARAM("System Table", "linux,uefi-system-table", system_table), 397 UEFI_PARAM("MemMap Address", "linux,uefi-mmap-start", mmap), 398 UEFI_PARAM("MemMap Size", "linux,uefi-mmap-size", mmap_size), 399 UEFI_PARAM("MemMap Desc. Size", "linux,uefi-mmap-desc-size", desc_size), 400 UEFI_PARAM("MemMap Desc. Version", "linux,uefi-mmap-desc-ver", desc_ver) 401 }; 402 403 struct param_info { 404 int verbose; 405 int found; 406 void *params; 407 }; 408 409 static int __init fdt_find_uefi_params(unsigned long node, const char *uname, 410 int depth, void *data) 411 { 412 struct param_info *info = data; 413 const void *prop; 414 void *dest; 415 u64 val; 416 int i, len; 417 418 if (depth != 1 || strcmp(uname, "chosen") != 0) 419 return 0; 420 421 for (i = 0; i < ARRAY_SIZE(dt_params); i++) { 422 prop = of_get_flat_dt_prop(node, dt_params[i].propname, &len); 423 if (!prop) 424 return 0; 425 dest = info->params + dt_params[i].offset; 426 info->found++; 427 428 val = of_read_number(prop, len / sizeof(u32)); 429 430 if (dt_params[i].size == sizeof(u32)) 431 *(u32 *)dest = val; 432 else 433 *(u64 *)dest = val; 434 435 if (info->verbose) 436 pr_info(" %s: 0x%0*llx\n", dt_params[i].name, 437 dt_params[i].size * 2, val); 438 } 439 return 1; 440 } 441 442 int __init efi_get_fdt_params(struct efi_fdt_params *params, int verbose) 443 { 444 struct param_info info; 445 int ret; 446 447 pr_info("Getting EFI parameters from FDT:\n"); 448 449 info.verbose = verbose; 450 info.found = 0; 451 info.params = params; 452 453 ret = of_scan_flat_dt(fdt_find_uefi_params, &info); 454 if (!info.found) 455 pr_info("UEFI not found.\n"); 456 else if (!ret) 457 pr_err("Can't find '%s' in device tree!\n", 458 dt_params[info.found].name); 459 460 return ret; 461 } 462 #endif /* CONFIG_EFI_PARAMS_FROM_FDT */ 463 464 static __initdata char memory_type_name[][20] = { 465 "Reserved", 466 "Loader Code", 467 "Loader Data", 468 "Boot Code", 469 "Boot Data", 470 "Runtime Code", 471 "Runtime Data", 472 "Conventional Memory", 473 "Unusable Memory", 474 "ACPI Reclaim Memory", 475 "ACPI Memory NVS", 476 "Memory Mapped I/O", 477 "MMIO Port Space", 478 "PAL Code" 479 }; 480 481 char * __init efi_md_typeattr_format(char *buf, size_t size, 482 const efi_memory_desc_t *md) 483 { 484 char *pos; 485 int type_len; 486 u64 attr; 487 488 pos = buf; 489 if (md->type >= ARRAY_SIZE(memory_type_name)) 490 type_len = snprintf(pos, size, "[type=%u", md->type); 491 else 492 type_len = snprintf(pos, size, "[%-*s", 493 (int)(sizeof(memory_type_name[0]) - 1), 494 memory_type_name[md->type]); 495 if (type_len >= size) 496 return buf; 497 498 pos += type_len; 499 size -= type_len; 500 501 attr = md->attribute; 502 if (attr & ~(EFI_MEMORY_UC | EFI_MEMORY_WC | EFI_MEMORY_WT | 503 EFI_MEMORY_WB | EFI_MEMORY_UCE | EFI_MEMORY_WP | 504 EFI_MEMORY_RP | EFI_MEMORY_XP | EFI_MEMORY_RUNTIME)) 505 snprintf(pos, size, "|attr=0x%016llx]", 506 (unsigned long long)attr); 507 else 508 snprintf(pos, size, "|%3s|%2s|%2s|%2s|%3s|%2s|%2s|%2s|%2s]", 509 attr & EFI_MEMORY_RUNTIME ? "RUN" : "", 510 attr & EFI_MEMORY_XP ? "XP" : "", 511 attr & EFI_MEMORY_RP ? "RP" : "", 512 attr & EFI_MEMORY_WP ? "WP" : "", 513 attr & EFI_MEMORY_UCE ? "UCE" : "", 514 attr & EFI_MEMORY_WB ? "WB" : "", 515 attr & EFI_MEMORY_WT ? "WT" : "", 516 attr & EFI_MEMORY_WC ? "WC" : "", 517 attr & EFI_MEMORY_UC ? "UC" : ""); 518 return buf; 519 } 520