xref: /openbmc/linux/drivers/firmware/efi/efi.c (revision 9fb29c73)
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/kexec.h>
27 #include <linux/platform_device.h>
28 #include <linux/random.h>
29 #include <linux/reboot.h>
30 #include <linux/slab.h>
31 #include <linux/acpi.h>
32 #include <linux/ucs2_string.h>
33 #include <linux/memblock.h>
34 
35 #include <asm/early_ioremap.h>
36 
37 struct efi __read_mostly efi = {
38 	.mps			= EFI_INVALID_TABLE_ADDR,
39 	.acpi			= EFI_INVALID_TABLE_ADDR,
40 	.acpi20			= EFI_INVALID_TABLE_ADDR,
41 	.smbios			= EFI_INVALID_TABLE_ADDR,
42 	.smbios3		= EFI_INVALID_TABLE_ADDR,
43 	.sal_systab		= EFI_INVALID_TABLE_ADDR,
44 	.boot_info		= EFI_INVALID_TABLE_ADDR,
45 	.hcdp			= EFI_INVALID_TABLE_ADDR,
46 	.uga			= EFI_INVALID_TABLE_ADDR,
47 	.uv_systab		= EFI_INVALID_TABLE_ADDR,
48 	.fw_vendor		= EFI_INVALID_TABLE_ADDR,
49 	.runtime		= EFI_INVALID_TABLE_ADDR,
50 	.config_table		= EFI_INVALID_TABLE_ADDR,
51 	.esrt			= EFI_INVALID_TABLE_ADDR,
52 	.properties_table	= EFI_INVALID_TABLE_ADDR,
53 	.mem_attr_table		= EFI_INVALID_TABLE_ADDR,
54 	.rng_seed		= EFI_INVALID_TABLE_ADDR,
55 	.tpm_log		= EFI_INVALID_TABLE_ADDR,
56 	.mem_reserve		= EFI_INVALID_TABLE_ADDR,
57 };
58 EXPORT_SYMBOL(efi);
59 
60 static unsigned long *efi_tables[] = {
61 	&efi.mps,
62 	&efi.acpi,
63 	&efi.acpi20,
64 	&efi.smbios,
65 	&efi.smbios3,
66 	&efi.sal_systab,
67 	&efi.boot_info,
68 	&efi.hcdp,
69 	&efi.uga,
70 	&efi.uv_systab,
71 	&efi.fw_vendor,
72 	&efi.runtime,
73 	&efi.config_table,
74 	&efi.esrt,
75 	&efi.properties_table,
76 	&efi.mem_attr_table,
77 };
78 
79 struct mm_struct efi_mm = {
80 	.mm_rb			= RB_ROOT,
81 	.mm_users		= ATOMIC_INIT(2),
82 	.mm_count		= ATOMIC_INIT(1),
83 	.mmap_sem		= __RWSEM_INITIALIZER(efi_mm.mmap_sem),
84 	.page_table_lock	= __SPIN_LOCK_UNLOCKED(efi_mm.page_table_lock),
85 	.mmlist			= LIST_HEAD_INIT(efi_mm.mmlist),
86 	.cpu_bitmap		= { [BITS_TO_LONGS(NR_CPUS)] = 0},
87 };
88 
89 struct workqueue_struct *efi_rts_wq;
90 
91 static bool disable_runtime;
92 static int __init setup_noefi(char *arg)
93 {
94 	disable_runtime = true;
95 	return 0;
96 }
97 early_param("noefi", setup_noefi);
98 
99 bool efi_runtime_disabled(void)
100 {
101 	return disable_runtime;
102 }
103 
104 static int __init parse_efi_cmdline(char *str)
105 {
106 	if (!str) {
107 		pr_warn("need at least one option\n");
108 		return -EINVAL;
109 	}
110 
111 	if (parse_option_str(str, "debug"))
112 		set_bit(EFI_DBG, &efi.flags);
113 
114 	if (parse_option_str(str, "noruntime"))
115 		disable_runtime = true;
116 
117 	return 0;
118 }
119 early_param("efi", parse_efi_cmdline);
120 
121 struct kobject *efi_kobj;
122 
123 /*
124  * Let's not leave out systab information that snuck into
125  * the efivars driver
126  * Note, do not add more fields in systab sysfs file as it breaks sysfs
127  * one value per file rule!
128  */
129 static ssize_t systab_show(struct kobject *kobj,
130 			   struct kobj_attribute *attr, char *buf)
131 {
132 	char *str = buf;
133 
134 	if (!kobj || !buf)
135 		return -EINVAL;
136 
137 	if (efi.mps != EFI_INVALID_TABLE_ADDR)
138 		str += sprintf(str, "MPS=0x%lx\n", efi.mps);
139 	if (efi.acpi20 != EFI_INVALID_TABLE_ADDR)
140 		str += sprintf(str, "ACPI20=0x%lx\n", efi.acpi20);
141 	if (efi.acpi != EFI_INVALID_TABLE_ADDR)
142 		str += sprintf(str, "ACPI=0x%lx\n", efi.acpi);
143 	/*
144 	 * If both SMBIOS and SMBIOS3 entry points are implemented, the
145 	 * SMBIOS3 entry point shall be preferred, so we list it first to
146 	 * let applications stop parsing after the first match.
147 	 */
148 	if (efi.smbios3 != EFI_INVALID_TABLE_ADDR)
149 		str += sprintf(str, "SMBIOS3=0x%lx\n", efi.smbios3);
150 	if (efi.smbios != EFI_INVALID_TABLE_ADDR)
151 		str += sprintf(str, "SMBIOS=0x%lx\n", efi.smbios);
152 	if (efi.hcdp != EFI_INVALID_TABLE_ADDR)
153 		str += sprintf(str, "HCDP=0x%lx\n", efi.hcdp);
154 	if (efi.boot_info != EFI_INVALID_TABLE_ADDR)
155 		str += sprintf(str, "BOOTINFO=0x%lx\n", efi.boot_info);
156 	if (efi.uga != EFI_INVALID_TABLE_ADDR)
157 		str += sprintf(str, "UGA=0x%lx\n", efi.uga);
158 
159 	return str - buf;
160 }
161 
162 static struct kobj_attribute efi_attr_systab = __ATTR_RO_MODE(systab, 0400);
163 
164 #define EFI_FIELD(var) efi.var
165 
166 #define EFI_ATTR_SHOW(name) \
167 static ssize_t name##_show(struct kobject *kobj, \
168 				struct kobj_attribute *attr, char *buf) \
169 { \
170 	return sprintf(buf, "0x%lx\n", EFI_FIELD(name)); \
171 }
172 
173 EFI_ATTR_SHOW(fw_vendor);
174 EFI_ATTR_SHOW(runtime);
175 EFI_ATTR_SHOW(config_table);
176 
177 static ssize_t fw_platform_size_show(struct kobject *kobj,
178 				     struct kobj_attribute *attr, char *buf)
179 {
180 	return sprintf(buf, "%d\n", efi_enabled(EFI_64BIT) ? 64 : 32);
181 }
182 
183 static struct kobj_attribute efi_attr_fw_vendor = __ATTR_RO(fw_vendor);
184 static struct kobj_attribute efi_attr_runtime = __ATTR_RO(runtime);
185 static struct kobj_attribute efi_attr_config_table = __ATTR_RO(config_table);
186 static struct kobj_attribute efi_attr_fw_platform_size =
187 	__ATTR_RO(fw_platform_size);
188 
189 static struct attribute *efi_subsys_attrs[] = {
190 	&efi_attr_systab.attr,
191 	&efi_attr_fw_vendor.attr,
192 	&efi_attr_runtime.attr,
193 	&efi_attr_config_table.attr,
194 	&efi_attr_fw_platform_size.attr,
195 	NULL,
196 };
197 
198 static umode_t efi_attr_is_visible(struct kobject *kobj,
199 				   struct attribute *attr, int n)
200 {
201 	if (attr == &efi_attr_fw_vendor.attr) {
202 		if (efi_enabled(EFI_PARAVIRT) ||
203 				efi.fw_vendor == EFI_INVALID_TABLE_ADDR)
204 			return 0;
205 	} else if (attr == &efi_attr_runtime.attr) {
206 		if (efi.runtime == EFI_INVALID_TABLE_ADDR)
207 			return 0;
208 	} else if (attr == &efi_attr_config_table.attr) {
209 		if (efi.config_table == EFI_INVALID_TABLE_ADDR)
210 			return 0;
211 	}
212 
213 	return attr->mode;
214 }
215 
216 static const struct attribute_group efi_subsys_attr_group = {
217 	.attrs = efi_subsys_attrs,
218 	.is_visible = efi_attr_is_visible,
219 };
220 
221 static struct efivars generic_efivars;
222 static struct efivar_operations generic_ops;
223 
224 static int generic_ops_register(void)
225 {
226 	generic_ops.get_variable = efi.get_variable;
227 	generic_ops.set_variable = efi.set_variable;
228 	generic_ops.set_variable_nonblocking = efi.set_variable_nonblocking;
229 	generic_ops.get_next_variable = efi.get_next_variable;
230 	generic_ops.query_variable_store = efi_query_variable_store;
231 
232 	return efivars_register(&generic_efivars, &generic_ops, efi_kobj);
233 }
234 
235 static void generic_ops_unregister(void)
236 {
237 	efivars_unregister(&generic_efivars);
238 }
239 
240 #if IS_ENABLED(CONFIG_ACPI)
241 #define EFIVAR_SSDT_NAME_MAX	16
242 static char efivar_ssdt[EFIVAR_SSDT_NAME_MAX] __initdata;
243 static int __init efivar_ssdt_setup(char *str)
244 {
245 	if (strlen(str) < sizeof(efivar_ssdt))
246 		memcpy(efivar_ssdt, str, strlen(str));
247 	else
248 		pr_warn("efivar_ssdt: name too long: %s\n", str);
249 	return 0;
250 }
251 __setup("efivar_ssdt=", efivar_ssdt_setup);
252 
253 static __init int efivar_ssdt_iter(efi_char16_t *name, efi_guid_t vendor,
254 				   unsigned long name_size, void *data)
255 {
256 	struct efivar_entry *entry;
257 	struct list_head *list = data;
258 	char utf8_name[EFIVAR_SSDT_NAME_MAX];
259 	int limit = min_t(unsigned long, EFIVAR_SSDT_NAME_MAX, name_size);
260 
261 	ucs2_as_utf8(utf8_name, name, limit - 1);
262 	if (strncmp(utf8_name, efivar_ssdt, limit) != 0)
263 		return 0;
264 
265 	entry = kmalloc(sizeof(*entry), GFP_KERNEL);
266 	if (!entry)
267 		return 0;
268 
269 	memcpy(entry->var.VariableName, name, name_size);
270 	memcpy(&entry->var.VendorGuid, &vendor, sizeof(efi_guid_t));
271 
272 	efivar_entry_add(entry, list);
273 
274 	return 0;
275 }
276 
277 static __init int efivar_ssdt_load(void)
278 {
279 	LIST_HEAD(entries);
280 	struct efivar_entry *entry, *aux;
281 	unsigned long size;
282 	void *data;
283 	int ret;
284 
285 	ret = efivar_init(efivar_ssdt_iter, &entries, true, &entries);
286 
287 	list_for_each_entry_safe(entry, aux, &entries, list) {
288 		pr_info("loading SSDT from variable %s-%pUl\n", efivar_ssdt,
289 			&entry->var.VendorGuid);
290 
291 		list_del(&entry->list);
292 
293 		ret = efivar_entry_size(entry, &size);
294 		if (ret) {
295 			pr_err("failed to get var size\n");
296 			goto free_entry;
297 		}
298 
299 		data = kmalloc(size, GFP_KERNEL);
300 		if (!data) {
301 			ret = -ENOMEM;
302 			goto free_entry;
303 		}
304 
305 		ret = efivar_entry_get(entry, NULL, &size, data);
306 		if (ret) {
307 			pr_err("failed to get var data\n");
308 			goto free_data;
309 		}
310 
311 		ret = acpi_load_table(data);
312 		if (ret) {
313 			pr_err("failed to load table: %d\n", ret);
314 			goto free_data;
315 		}
316 
317 		goto free_entry;
318 
319 free_data:
320 		kfree(data);
321 
322 free_entry:
323 		kfree(entry);
324 	}
325 
326 	return ret;
327 }
328 #else
329 static inline int efivar_ssdt_load(void) { return 0; }
330 #endif
331 
332 /*
333  * We register the efi subsystem with the firmware subsystem and the
334  * efivars subsystem with the efi subsystem, if the system was booted with
335  * EFI.
336  */
337 static int __init efisubsys_init(void)
338 {
339 	int error;
340 
341 	if (!efi_enabled(EFI_BOOT))
342 		return 0;
343 
344 	/*
345 	 * Since we process only one efi_runtime_service() at a time, an
346 	 * ordered workqueue (which creates only one execution context)
347 	 * should suffice all our needs.
348 	 */
349 	efi_rts_wq = alloc_ordered_workqueue("efi_rts_wq", 0);
350 	if (!efi_rts_wq) {
351 		pr_err("Creating efi_rts_wq failed, EFI runtime services disabled.\n");
352 		clear_bit(EFI_RUNTIME_SERVICES, &efi.flags);
353 		return 0;
354 	}
355 
356 	/* We register the efi directory at /sys/firmware/efi */
357 	efi_kobj = kobject_create_and_add("efi", firmware_kobj);
358 	if (!efi_kobj) {
359 		pr_err("efi: Firmware registration failed.\n");
360 		return -ENOMEM;
361 	}
362 
363 	error = generic_ops_register();
364 	if (error)
365 		goto err_put;
366 
367 	if (efi_enabled(EFI_RUNTIME_SERVICES))
368 		efivar_ssdt_load();
369 
370 	error = sysfs_create_group(efi_kobj, &efi_subsys_attr_group);
371 	if (error) {
372 		pr_err("efi: Sysfs attribute export failed with error %d.\n",
373 		       error);
374 		goto err_unregister;
375 	}
376 
377 	error = efi_runtime_map_init(efi_kobj);
378 	if (error)
379 		goto err_remove_group;
380 
381 	/* and the standard mountpoint for efivarfs */
382 	error = sysfs_create_mount_point(efi_kobj, "efivars");
383 	if (error) {
384 		pr_err("efivars: Subsystem registration failed.\n");
385 		goto err_remove_group;
386 	}
387 
388 	return 0;
389 
390 err_remove_group:
391 	sysfs_remove_group(efi_kobj, &efi_subsys_attr_group);
392 err_unregister:
393 	generic_ops_unregister();
394 err_put:
395 	kobject_put(efi_kobj);
396 	return error;
397 }
398 
399 subsys_initcall(efisubsys_init);
400 
401 /*
402  * Find the efi memory descriptor for a given physical address.  Given a
403  * physical address, determine if it exists within an EFI Memory Map entry,
404  * and if so, populate the supplied memory descriptor with the appropriate
405  * data.
406  */
407 int efi_mem_desc_lookup(u64 phys_addr, efi_memory_desc_t *out_md)
408 {
409 	efi_memory_desc_t *md;
410 
411 	if (!efi_enabled(EFI_MEMMAP)) {
412 		pr_err_once("EFI_MEMMAP is not enabled.\n");
413 		return -EINVAL;
414 	}
415 
416 	if (!out_md) {
417 		pr_err_once("out_md is null.\n");
418 		return -EINVAL;
419         }
420 
421 	for_each_efi_memory_desc(md) {
422 		u64 size;
423 		u64 end;
424 
425 		size = md->num_pages << EFI_PAGE_SHIFT;
426 		end = md->phys_addr + size;
427 		if (phys_addr >= md->phys_addr && phys_addr < end) {
428 			memcpy(out_md, md, sizeof(*out_md));
429 			return 0;
430 		}
431 	}
432 	return -ENOENT;
433 }
434 
435 /*
436  * Calculate the highest address of an efi memory descriptor.
437  */
438 u64 __init efi_mem_desc_end(efi_memory_desc_t *md)
439 {
440 	u64 size = md->num_pages << EFI_PAGE_SHIFT;
441 	u64 end = md->phys_addr + size;
442 	return end;
443 }
444 
445 void __init __weak efi_arch_mem_reserve(phys_addr_t addr, u64 size) {}
446 
447 /**
448  * efi_mem_reserve - Reserve an EFI memory region
449  * @addr: Physical address to reserve
450  * @size: Size of reservation
451  *
452  * Mark a region as reserved from general kernel allocation and
453  * prevent it being released by efi_free_boot_services().
454  *
455  * This function should be called drivers once they've parsed EFI
456  * configuration tables to figure out where their data lives, e.g.
457  * efi_esrt_init().
458  */
459 void __init efi_mem_reserve(phys_addr_t addr, u64 size)
460 {
461 	if (!memblock_is_region_reserved(addr, size))
462 		memblock_reserve(addr, size);
463 
464 	/*
465 	 * Some architectures (x86) reserve all boot services ranges
466 	 * until efi_free_boot_services() because of buggy firmware
467 	 * implementations. This means the above memblock_reserve() is
468 	 * superfluous on x86 and instead what it needs to do is
469 	 * ensure the @start, @size is not freed.
470 	 */
471 	efi_arch_mem_reserve(addr, size);
472 }
473 
474 static __initdata efi_config_table_type_t common_tables[] = {
475 	{ACPI_20_TABLE_GUID, "ACPI 2.0", &efi.acpi20},
476 	{ACPI_TABLE_GUID, "ACPI", &efi.acpi},
477 	{HCDP_TABLE_GUID, "HCDP", &efi.hcdp},
478 	{MPS_TABLE_GUID, "MPS", &efi.mps},
479 	{SAL_SYSTEM_TABLE_GUID, "SALsystab", &efi.sal_systab},
480 	{SMBIOS_TABLE_GUID, "SMBIOS", &efi.smbios},
481 	{SMBIOS3_TABLE_GUID, "SMBIOS 3.0", &efi.smbios3},
482 	{UGA_IO_PROTOCOL_GUID, "UGA", &efi.uga},
483 	{EFI_SYSTEM_RESOURCE_TABLE_GUID, "ESRT", &efi.esrt},
484 	{EFI_PROPERTIES_TABLE_GUID, "PROP", &efi.properties_table},
485 	{EFI_MEMORY_ATTRIBUTES_TABLE_GUID, "MEMATTR", &efi.mem_attr_table},
486 	{LINUX_EFI_RANDOM_SEED_TABLE_GUID, "RNG", &efi.rng_seed},
487 	{LINUX_EFI_TPM_EVENT_LOG_GUID, "TPMEventLog", &efi.tpm_log},
488 	{LINUX_EFI_MEMRESERVE_TABLE_GUID, "MEMRESERVE", &efi.mem_reserve},
489 	{NULL_GUID, NULL, NULL},
490 };
491 
492 static __init int match_config_table(efi_guid_t *guid,
493 				     unsigned long table,
494 				     efi_config_table_type_t *table_types)
495 {
496 	int i;
497 
498 	if (table_types) {
499 		for (i = 0; efi_guidcmp(table_types[i].guid, NULL_GUID); i++) {
500 			if (!efi_guidcmp(*guid, table_types[i].guid)) {
501 				*(table_types[i].ptr) = table;
502 				if (table_types[i].name)
503 					pr_cont(" %s=0x%lx ",
504 						table_types[i].name, table);
505 				return 1;
506 			}
507 		}
508 	}
509 
510 	return 0;
511 }
512 
513 int __init efi_config_parse_tables(void *config_tables, int count, int sz,
514 				   efi_config_table_type_t *arch_tables)
515 {
516 	void *tablep;
517 	int i;
518 
519 	tablep = config_tables;
520 	pr_info("");
521 	for (i = 0; i < count; i++) {
522 		efi_guid_t guid;
523 		unsigned long table;
524 
525 		if (efi_enabled(EFI_64BIT)) {
526 			u64 table64;
527 			guid = ((efi_config_table_64_t *)tablep)->guid;
528 			table64 = ((efi_config_table_64_t *)tablep)->table;
529 			table = table64;
530 #ifndef CONFIG_64BIT
531 			if (table64 >> 32) {
532 				pr_cont("\n");
533 				pr_err("Table located above 4GB, disabling EFI.\n");
534 				return -EINVAL;
535 			}
536 #endif
537 		} else {
538 			guid = ((efi_config_table_32_t *)tablep)->guid;
539 			table = ((efi_config_table_32_t *)tablep)->table;
540 		}
541 
542 		if (!match_config_table(&guid, table, common_tables))
543 			match_config_table(&guid, table, arch_tables);
544 
545 		tablep += sz;
546 	}
547 	pr_cont("\n");
548 	set_bit(EFI_CONFIG_TABLES, &efi.flags);
549 
550 	if (efi.rng_seed != EFI_INVALID_TABLE_ADDR) {
551 		struct linux_efi_random_seed *seed;
552 		u32 size = 0;
553 
554 		seed = early_memremap(efi.rng_seed, sizeof(*seed));
555 		if (seed != NULL) {
556 			size = seed->size;
557 			early_memunmap(seed, sizeof(*seed));
558 		} else {
559 			pr_err("Could not map UEFI random seed!\n");
560 		}
561 		if (size > 0) {
562 			seed = early_memremap(efi.rng_seed,
563 					      sizeof(*seed) + size);
564 			if (seed != NULL) {
565 				pr_notice("seeding entropy pool\n");
566 				add_device_randomness(seed->bits, seed->size);
567 				early_memunmap(seed, sizeof(*seed) + size);
568 			} else {
569 				pr_err("Could not map UEFI random seed!\n");
570 			}
571 		}
572 	}
573 
574 	if (efi_enabled(EFI_MEMMAP))
575 		efi_memattr_init();
576 
577 	efi_tpm_eventlog_init();
578 
579 	/* Parse the EFI Properties table if it exists */
580 	if (efi.properties_table != EFI_INVALID_TABLE_ADDR) {
581 		efi_properties_table_t *tbl;
582 
583 		tbl = early_memremap(efi.properties_table, sizeof(*tbl));
584 		if (tbl == NULL) {
585 			pr_err("Could not map Properties table!\n");
586 			return -ENOMEM;
587 		}
588 
589 		if (tbl->memory_protection_attribute &
590 		    EFI_PROPERTIES_RUNTIME_MEMORY_PROTECTION_NON_EXECUTABLE_PE_DATA)
591 			set_bit(EFI_NX_PE_DATA, &efi.flags);
592 
593 		early_memunmap(tbl, sizeof(*tbl));
594 	}
595 	return 0;
596 }
597 
598 int __init efi_apply_persistent_mem_reservations(void)
599 {
600 	if (efi.mem_reserve != EFI_INVALID_TABLE_ADDR) {
601 		unsigned long prsv = efi.mem_reserve;
602 
603 		while (prsv) {
604 			struct linux_efi_memreserve *rsv;
605 			u8 *p;
606 			int i;
607 
608 			/*
609 			 * Just map a full page: that is what we will get
610 			 * anyway, and it permits us to map the entire entry
611 			 * before knowing its size.
612 			 */
613 			p = early_memremap(ALIGN_DOWN(prsv, PAGE_SIZE),
614 					   PAGE_SIZE);
615 			if (p == NULL) {
616 				pr_err("Could not map UEFI memreserve entry!\n");
617 				return -ENOMEM;
618 			}
619 
620 			rsv = (void *)(p + prsv % PAGE_SIZE);
621 
622 			/* reserve the entry itself */
623 			memblock_reserve(prsv, EFI_MEMRESERVE_SIZE(rsv->size));
624 
625 			for (i = 0; i < atomic_read(&rsv->count); i++) {
626 				memblock_reserve(rsv->entry[i].base,
627 						 rsv->entry[i].size);
628 			}
629 
630 			prsv = rsv->next;
631 			early_memunmap(p, PAGE_SIZE);
632 		}
633 	}
634 
635 	return 0;
636 }
637 
638 int __init efi_config_init(efi_config_table_type_t *arch_tables)
639 {
640 	void *config_tables;
641 	int sz, ret;
642 
643 	if (efi_enabled(EFI_64BIT))
644 		sz = sizeof(efi_config_table_64_t);
645 	else
646 		sz = sizeof(efi_config_table_32_t);
647 
648 	/*
649 	 * Let's see what config tables the firmware passed to us.
650 	 */
651 	config_tables = early_memremap(efi.systab->tables,
652 				       efi.systab->nr_tables * sz);
653 	if (config_tables == NULL) {
654 		pr_err("Could not map Configuration table!\n");
655 		return -ENOMEM;
656 	}
657 
658 	ret = efi_config_parse_tables(config_tables, efi.systab->nr_tables, sz,
659 				      arch_tables);
660 
661 	early_memunmap(config_tables, efi.systab->nr_tables * sz);
662 	return ret;
663 }
664 
665 #ifdef CONFIG_EFI_VARS_MODULE
666 static int __init efi_load_efivars(void)
667 {
668 	struct platform_device *pdev;
669 
670 	if (!efi_enabled(EFI_RUNTIME_SERVICES))
671 		return 0;
672 
673 	pdev = platform_device_register_simple("efivars", 0, NULL, 0);
674 	return PTR_ERR_OR_ZERO(pdev);
675 }
676 device_initcall(efi_load_efivars);
677 #endif
678 
679 #ifdef CONFIG_EFI_PARAMS_FROM_FDT
680 
681 #define UEFI_PARAM(name, prop, field)			   \
682 	{						   \
683 		{ name },				   \
684 		{ prop },				   \
685 		offsetof(struct efi_fdt_params, field),    \
686 		FIELD_SIZEOF(struct efi_fdt_params, field) \
687 	}
688 
689 struct params {
690 	const char name[32];
691 	const char propname[32];
692 	int offset;
693 	int size;
694 };
695 
696 static __initdata struct params fdt_params[] = {
697 	UEFI_PARAM("System Table", "linux,uefi-system-table", system_table),
698 	UEFI_PARAM("MemMap Address", "linux,uefi-mmap-start", mmap),
699 	UEFI_PARAM("MemMap Size", "linux,uefi-mmap-size", mmap_size),
700 	UEFI_PARAM("MemMap Desc. Size", "linux,uefi-mmap-desc-size", desc_size),
701 	UEFI_PARAM("MemMap Desc. Version", "linux,uefi-mmap-desc-ver", desc_ver)
702 };
703 
704 static __initdata struct params xen_fdt_params[] = {
705 	UEFI_PARAM("System Table", "xen,uefi-system-table", system_table),
706 	UEFI_PARAM("MemMap Address", "xen,uefi-mmap-start", mmap),
707 	UEFI_PARAM("MemMap Size", "xen,uefi-mmap-size", mmap_size),
708 	UEFI_PARAM("MemMap Desc. Size", "xen,uefi-mmap-desc-size", desc_size),
709 	UEFI_PARAM("MemMap Desc. Version", "xen,uefi-mmap-desc-ver", desc_ver)
710 };
711 
712 #define EFI_FDT_PARAMS_SIZE	ARRAY_SIZE(fdt_params)
713 
714 static __initdata struct {
715 	const char *uname;
716 	const char *subnode;
717 	struct params *params;
718 } dt_params[] = {
719 	{ "hypervisor", "uefi", xen_fdt_params },
720 	{ "chosen", NULL, fdt_params },
721 };
722 
723 struct param_info {
724 	int found;
725 	void *params;
726 	const char *missing;
727 };
728 
729 static int __init __find_uefi_params(unsigned long node,
730 				     struct param_info *info,
731 				     struct params *params)
732 {
733 	const void *prop;
734 	void *dest;
735 	u64 val;
736 	int i, len;
737 
738 	for (i = 0; i < EFI_FDT_PARAMS_SIZE; i++) {
739 		prop = of_get_flat_dt_prop(node, params[i].propname, &len);
740 		if (!prop) {
741 			info->missing = params[i].name;
742 			return 0;
743 		}
744 
745 		dest = info->params + params[i].offset;
746 		info->found++;
747 
748 		val = of_read_number(prop, len / sizeof(u32));
749 
750 		if (params[i].size == sizeof(u32))
751 			*(u32 *)dest = val;
752 		else
753 			*(u64 *)dest = val;
754 
755 		if (efi_enabled(EFI_DBG))
756 			pr_info("  %s: 0x%0*llx\n", params[i].name,
757 				params[i].size * 2, val);
758 	}
759 
760 	return 1;
761 }
762 
763 static int __init fdt_find_uefi_params(unsigned long node, const char *uname,
764 				       int depth, void *data)
765 {
766 	struct param_info *info = data;
767 	int i;
768 
769 	for (i = 0; i < ARRAY_SIZE(dt_params); i++) {
770 		const char *subnode = dt_params[i].subnode;
771 
772 		if (depth != 1 || strcmp(uname, dt_params[i].uname) != 0) {
773 			info->missing = dt_params[i].params[0].name;
774 			continue;
775 		}
776 
777 		if (subnode) {
778 			int err = of_get_flat_dt_subnode_by_name(node, subnode);
779 
780 			if (err < 0)
781 				return 0;
782 
783 			node = err;
784 		}
785 
786 		return __find_uefi_params(node, info, dt_params[i].params);
787 	}
788 
789 	return 0;
790 }
791 
792 int __init efi_get_fdt_params(struct efi_fdt_params *params)
793 {
794 	struct param_info info;
795 	int ret;
796 
797 	pr_info("Getting EFI parameters from FDT:\n");
798 
799 	info.found = 0;
800 	info.params = params;
801 
802 	ret = of_scan_flat_dt(fdt_find_uefi_params, &info);
803 	if (!info.found)
804 		pr_info("UEFI not found.\n");
805 	else if (!ret)
806 		pr_err("Can't find '%s' in device tree!\n",
807 		       info.missing);
808 
809 	return ret;
810 }
811 #endif /* CONFIG_EFI_PARAMS_FROM_FDT */
812 
813 static __initdata char memory_type_name[][20] = {
814 	"Reserved",
815 	"Loader Code",
816 	"Loader Data",
817 	"Boot Code",
818 	"Boot Data",
819 	"Runtime Code",
820 	"Runtime Data",
821 	"Conventional Memory",
822 	"Unusable Memory",
823 	"ACPI Reclaim Memory",
824 	"ACPI Memory NVS",
825 	"Memory Mapped I/O",
826 	"MMIO Port Space",
827 	"PAL Code",
828 	"Persistent Memory",
829 };
830 
831 char * __init efi_md_typeattr_format(char *buf, size_t size,
832 				     const efi_memory_desc_t *md)
833 {
834 	char *pos;
835 	int type_len;
836 	u64 attr;
837 
838 	pos = buf;
839 	if (md->type >= ARRAY_SIZE(memory_type_name))
840 		type_len = snprintf(pos, size, "[type=%u", md->type);
841 	else
842 		type_len = snprintf(pos, size, "[%-*s",
843 				    (int)(sizeof(memory_type_name[0]) - 1),
844 				    memory_type_name[md->type]);
845 	if (type_len >= size)
846 		return buf;
847 
848 	pos += type_len;
849 	size -= type_len;
850 
851 	attr = md->attribute;
852 	if (attr & ~(EFI_MEMORY_UC | EFI_MEMORY_WC | EFI_MEMORY_WT |
853 		     EFI_MEMORY_WB | EFI_MEMORY_UCE | EFI_MEMORY_RO |
854 		     EFI_MEMORY_WP | EFI_MEMORY_RP | EFI_MEMORY_XP |
855 		     EFI_MEMORY_NV |
856 		     EFI_MEMORY_RUNTIME | EFI_MEMORY_MORE_RELIABLE))
857 		snprintf(pos, size, "|attr=0x%016llx]",
858 			 (unsigned long long)attr);
859 	else
860 		snprintf(pos, size,
861 			 "|%3s|%2s|%2s|%2s|%2s|%2s|%2s|%3s|%2s|%2s|%2s|%2s]",
862 			 attr & EFI_MEMORY_RUNTIME ? "RUN" : "",
863 			 attr & EFI_MEMORY_MORE_RELIABLE ? "MR" : "",
864 			 attr & EFI_MEMORY_NV      ? "NV"  : "",
865 			 attr & EFI_MEMORY_XP      ? "XP"  : "",
866 			 attr & EFI_MEMORY_RP      ? "RP"  : "",
867 			 attr & EFI_MEMORY_WP      ? "WP"  : "",
868 			 attr & EFI_MEMORY_RO      ? "RO"  : "",
869 			 attr & EFI_MEMORY_UCE     ? "UCE" : "",
870 			 attr & EFI_MEMORY_WB      ? "WB"  : "",
871 			 attr & EFI_MEMORY_WT      ? "WT"  : "",
872 			 attr & EFI_MEMORY_WC      ? "WC"  : "",
873 			 attr & EFI_MEMORY_UC      ? "UC"  : "");
874 	return buf;
875 }
876 
877 /*
878  * IA64 has a funky EFI memory map that doesn't work the same way as
879  * other architectures.
880  */
881 #ifndef CONFIG_IA64
882 /*
883  * efi_mem_attributes - lookup memmap attributes for physical address
884  * @phys_addr: the physical address to lookup
885  *
886  * Search in the EFI memory map for the region covering
887  * @phys_addr. Returns the EFI memory attributes if the region
888  * was found in the memory map, 0 otherwise.
889  */
890 u64 efi_mem_attributes(unsigned long phys_addr)
891 {
892 	efi_memory_desc_t *md;
893 
894 	if (!efi_enabled(EFI_MEMMAP))
895 		return 0;
896 
897 	for_each_efi_memory_desc(md) {
898 		if ((md->phys_addr <= phys_addr) &&
899 		    (phys_addr < (md->phys_addr +
900 		    (md->num_pages << EFI_PAGE_SHIFT))))
901 			return md->attribute;
902 	}
903 	return 0;
904 }
905 
906 /*
907  * efi_mem_type - lookup memmap type for physical address
908  * @phys_addr: the physical address to lookup
909  *
910  * Search in the EFI memory map for the region covering @phys_addr.
911  * Returns the EFI memory type if the region was found in the memory
912  * map, EFI_RESERVED_TYPE (zero) otherwise.
913  */
914 int efi_mem_type(unsigned long phys_addr)
915 {
916 	const efi_memory_desc_t *md;
917 
918 	if (!efi_enabled(EFI_MEMMAP))
919 		return -ENOTSUPP;
920 
921 	for_each_efi_memory_desc(md) {
922 		if ((md->phys_addr <= phys_addr) &&
923 		    (phys_addr < (md->phys_addr +
924 				  (md->num_pages << EFI_PAGE_SHIFT))))
925 			return md->type;
926 	}
927 	return -EINVAL;
928 }
929 #endif
930 
931 int efi_status_to_err(efi_status_t status)
932 {
933 	int err;
934 
935 	switch (status) {
936 	case EFI_SUCCESS:
937 		err = 0;
938 		break;
939 	case EFI_INVALID_PARAMETER:
940 		err = -EINVAL;
941 		break;
942 	case EFI_OUT_OF_RESOURCES:
943 		err = -ENOSPC;
944 		break;
945 	case EFI_DEVICE_ERROR:
946 		err = -EIO;
947 		break;
948 	case EFI_WRITE_PROTECTED:
949 		err = -EROFS;
950 		break;
951 	case EFI_SECURITY_VIOLATION:
952 		err = -EACCES;
953 		break;
954 	case EFI_NOT_FOUND:
955 		err = -ENOENT;
956 		break;
957 	case EFI_ABORTED:
958 		err = -EINTR;
959 		break;
960 	default:
961 		err = -EINVAL;
962 	}
963 
964 	return err;
965 }
966 
967 bool efi_is_table_address(unsigned long phys_addr)
968 {
969 	unsigned int i;
970 
971 	if (phys_addr == EFI_INVALID_TABLE_ADDR)
972 		return false;
973 
974 	for (i = 0; i < ARRAY_SIZE(efi_tables); i++)
975 		if (*(efi_tables[i]) == phys_addr)
976 			return true;
977 
978 	return false;
979 }
980 
981 static DEFINE_SPINLOCK(efi_mem_reserve_persistent_lock);
982 static struct linux_efi_memreserve *efi_memreserve_root __ro_after_init;
983 
984 static int __init efi_memreserve_map_root(void)
985 {
986 	if (efi.mem_reserve == EFI_INVALID_TABLE_ADDR)
987 		return -ENODEV;
988 
989 	efi_memreserve_root = memremap(efi.mem_reserve,
990 				       sizeof(*efi_memreserve_root),
991 				       MEMREMAP_WB);
992 	if (WARN_ON_ONCE(!efi_memreserve_root))
993 		return -ENOMEM;
994 	return 0;
995 }
996 
997 int __ref efi_mem_reserve_persistent(phys_addr_t addr, u64 size)
998 {
999 	struct linux_efi_memreserve *rsv;
1000 	unsigned long prsv;
1001 	int rc, index;
1002 
1003 	if (efi_memreserve_root == (void *)ULONG_MAX)
1004 		return -ENODEV;
1005 
1006 	if (!efi_memreserve_root) {
1007 		rc = efi_memreserve_map_root();
1008 		if (rc)
1009 			return rc;
1010 	}
1011 
1012 	/* first try to find a slot in an existing linked list entry */
1013 	for (prsv = efi_memreserve_root->next; prsv; prsv = rsv->next) {
1014 		rsv = __va(prsv);
1015 		index = atomic_fetch_add_unless(&rsv->count, 1, rsv->size);
1016 		if (index < rsv->size) {
1017 			rsv->entry[index].base = addr;
1018 			rsv->entry[index].size = size;
1019 
1020 			return 0;
1021 		}
1022 	}
1023 
1024 	/* no slot found - allocate a new linked list entry */
1025 	rsv = (struct linux_efi_memreserve *)__get_free_page(GFP_ATOMIC);
1026 	if (!rsv)
1027 		return -ENOMEM;
1028 
1029 	rsv->size = EFI_MEMRESERVE_COUNT(PAGE_SIZE);
1030 	atomic_set(&rsv->count, 1);
1031 	rsv->entry[0].base = addr;
1032 	rsv->entry[0].size = size;
1033 
1034 	spin_lock(&efi_mem_reserve_persistent_lock);
1035 	rsv->next = efi_memreserve_root->next;
1036 	efi_memreserve_root->next = __pa(rsv);
1037 	spin_unlock(&efi_mem_reserve_persistent_lock);
1038 
1039 	return 0;
1040 }
1041 
1042 static int __init efi_memreserve_root_init(void)
1043 {
1044 	if (efi_memreserve_root)
1045 		return 0;
1046 	if (efi_memreserve_map_root())
1047 		efi_memreserve_root = (void *)ULONG_MAX;
1048 	return 0;
1049 }
1050 early_initcall(efi_memreserve_root_init);
1051 
1052 #ifdef CONFIG_KEXEC
1053 static int update_efi_random_seed(struct notifier_block *nb,
1054 				  unsigned long code, void *unused)
1055 {
1056 	struct linux_efi_random_seed *seed;
1057 	u32 size = 0;
1058 
1059 	if (!kexec_in_progress)
1060 		return NOTIFY_DONE;
1061 
1062 	seed = memremap(efi.rng_seed, sizeof(*seed), MEMREMAP_WB);
1063 	if (seed != NULL) {
1064 		size = min(seed->size, EFI_RANDOM_SEED_SIZE);
1065 		memunmap(seed);
1066 	} else {
1067 		pr_err("Could not map UEFI random seed!\n");
1068 	}
1069 	if (size > 0) {
1070 		seed = memremap(efi.rng_seed, sizeof(*seed) + size,
1071 				MEMREMAP_WB);
1072 		if (seed != NULL) {
1073 			seed->size = size;
1074 			get_random_bytes(seed->bits, seed->size);
1075 			memunmap(seed);
1076 		} else {
1077 			pr_err("Could not map UEFI random seed!\n");
1078 		}
1079 	}
1080 	return NOTIFY_DONE;
1081 }
1082 
1083 static struct notifier_block efi_random_seed_nb = {
1084 	.notifier_call = update_efi_random_seed,
1085 };
1086 
1087 static int register_update_efi_random_seed(void)
1088 {
1089 	if (efi.rng_seed == EFI_INVALID_TABLE_ADDR)
1090 		return 0;
1091 	return register_reboot_notifier(&efi_random_seed_nb);
1092 }
1093 late_initcall(register_update_efi_random_seed);
1094 #endif
1095