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