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