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