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