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