xref: /openbmc/linux/drivers/firmware/efi/efi.c (revision c8dbaa22) 
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 };
56 EXPORT_SYMBOL(efi);
57 
58 static bool disable_runtime;
59 static int __init setup_noefi(char *arg)
60 {
61 	disable_runtime = true;
62 	return 0;
63 }
64 early_param("noefi", setup_noefi);
65 
66 bool efi_runtime_disabled(void)
67 {
68 	return disable_runtime;
69 }
70 
71 static int __init parse_efi_cmdline(char *str)
72 {
73 	if (!str) {
74 		pr_warn("need at least one option\n");
75 		return -EINVAL;
76 	}
77 
78 	if (parse_option_str(str, "debug"))
79 		set_bit(EFI_DBG, &efi.flags);
80 
81 	if (parse_option_str(str, "noruntime"))
82 		disable_runtime = true;
83 
84 	return 0;
85 }
86 early_param("efi", parse_efi_cmdline);
87 
88 struct kobject *efi_kobj;
89 
90 /*
91  * Let's not leave out systab information that snuck into
92  * the efivars driver
93  */
94 static ssize_t systab_show(struct kobject *kobj,
95 			   struct kobj_attribute *attr, char *buf)
96 {
97 	char *str = buf;
98 
99 	if (!kobj || !buf)
100 		return -EINVAL;
101 
102 	if (efi.mps != EFI_INVALID_TABLE_ADDR)
103 		str += sprintf(str, "MPS=0x%lx\n", efi.mps);
104 	if (efi.acpi20 != EFI_INVALID_TABLE_ADDR)
105 		str += sprintf(str, "ACPI20=0x%lx\n", efi.acpi20);
106 	if (efi.acpi != EFI_INVALID_TABLE_ADDR)
107 		str += sprintf(str, "ACPI=0x%lx\n", efi.acpi);
108 	/*
109 	 * If both SMBIOS and SMBIOS3 entry points are implemented, the
110 	 * SMBIOS3 entry point shall be preferred, so we list it first to
111 	 * let applications stop parsing after the first match.
112 	 */
113 	if (efi.smbios3 != EFI_INVALID_TABLE_ADDR)
114 		str += sprintf(str, "SMBIOS3=0x%lx\n", efi.smbios3);
115 	if (efi.smbios != EFI_INVALID_TABLE_ADDR)
116 		str += sprintf(str, "SMBIOS=0x%lx\n", efi.smbios);
117 	if (efi.hcdp != EFI_INVALID_TABLE_ADDR)
118 		str += sprintf(str, "HCDP=0x%lx\n", efi.hcdp);
119 	if (efi.boot_info != EFI_INVALID_TABLE_ADDR)
120 		str += sprintf(str, "BOOTINFO=0x%lx\n", efi.boot_info);
121 	if (efi.uga != EFI_INVALID_TABLE_ADDR)
122 		str += sprintf(str, "UGA=0x%lx\n", efi.uga);
123 
124 	return str - buf;
125 }
126 
127 static struct kobj_attribute efi_attr_systab =
128 			__ATTR(systab, 0400, systab_show, NULL);
129 
130 #define EFI_FIELD(var) efi.var
131 
132 #define EFI_ATTR_SHOW(name) \
133 static ssize_t name##_show(struct kobject *kobj, \
134 				struct kobj_attribute *attr, char *buf) \
135 { \
136 	return sprintf(buf, "0x%lx\n", EFI_FIELD(name)); \
137 }
138 
139 EFI_ATTR_SHOW(fw_vendor);
140 EFI_ATTR_SHOW(runtime);
141 EFI_ATTR_SHOW(config_table);
142 
143 static ssize_t fw_platform_size_show(struct kobject *kobj,
144 				     struct kobj_attribute *attr, char *buf)
145 {
146 	return sprintf(buf, "%d\n", efi_enabled(EFI_64BIT) ? 64 : 32);
147 }
148 
149 static struct kobj_attribute efi_attr_fw_vendor = __ATTR_RO(fw_vendor);
150 static struct kobj_attribute efi_attr_runtime = __ATTR_RO(runtime);
151 static struct kobj_attribute efi_attr_config_table = __ATTR_RO(config_table);
152 static struct kobj_attribute efi_attr_fw_platform_size =
153 	__ATTR_RO(fw_platform_size);
154 
155 static struct attribute *efi_subsys_attrs[] = {
156 	&efi_attr_systab.attr,
157 	&efi_attr_fw_vendor.attr,
158 	&efi_attr_runtime.attr,
159 	&efi_attr_config_table.attr,
160 	&efi_attr_fw_platform_size.attr,
161 	NULL,
162 };
163 
164 static umode_t efi_attr_is_visible(struct kobject *kobj,
165 				   struct attribute *attr, int n)
166 {
167 	if (attr == &efi_attr_fw_vendor.attr) {
168 		if (efi_enabled(EFI_PARAVIRT) ||
169 				efi.fw_vendor == EFI_INVALID_TABLE_ADDR)
170 			return 0;
171 	} else if (attr == &efi_attr_runtime.attr) {
172 		if (efi.runtime == EFI_INVALID_TABLE_ADDR)
173 			return 0;
174 	} else if (attr == &efi_attr_config_table.attr) {
175 		if (efi.config_table == EFI_INVALID_TABLE_ADDR)
176 			return 0;
177 	}
178 
179 	return attr->mode;
180 }
181 
182 static struct attribute_group efi_subsys_attr_group = {
183 	.attrs = efi_subsys_attrs,
184 	.is_visible = efi_attr_is_visible,
185 };
186 
187 static struct efivars generic_efivars;
188 static struct efivar_operations generic_ops;
189 
190 static int generic_ops_register(void)
191 {
192 	generic_ops.get_variable = efi.get_variable;
193 	generic_ops.set_variable = efi.set_variable;
194 	generic_ops.set_variable_nonblocking = efi.set_variable_nonblocking;
195 	generic_ops.get_next_variable = efi.get_next_variable;
196 	generic_ops.query_variable_store = efi_query_variable_store;
197 
198 	return efivars_register(&generic_efivars, &generic_ops, efi_kobj);
199 }
200 
201 static void generic_ops_unregister(void)
202 {
203 	efivars_unregister(&generic_efivars);
204 }
205 
206 #if IS_ENABLED(CONFIG_ACPI)
207 #define EFIVAR_SSDT_NAME_MAX	16
208 static char efivar_ssdt[EFIVAR_SSDT_NAME_MAX] __initdata;
209 static int __init efivar_ssdt_setup(char *str)
210 {
211 	if (strlen(str) < sizeof(efivar_ssdt))
212 		memcpy(efivar_ssdt, str, strlen(str));
213 	else
214 		pr_warn("efivar_ssdt: name too long: %s\n", str);
215 	return 0;
216 }
217 __setup("efivar_ssdt=", efivar_ssdt_setup);
218 
219 static __init int efivar_ssdt_iter(efi_char16_t *name, efi_guid_t vendor,
220 				   unsigned long name_size, void *data)
221 {
222 	struct efivar_entry *entry;
223 	struct list_head *list = data;
224 	char utf8_name[EFIVAR_SSDT_NAME_MAX];
225 	int limit = min_t(unsigned long, EFIVAR_SSDT_NAME_MAX, name_size);
226 
227 	ucs2_as_utf8(utf8_name, name, limit - 1);
228 	if (strncmp(utf8_name, efivar_ssdt, limit) != 0)
229 		return 0;
230 
231 	entry = kmalloc(sizeof(*entry), GFP_KERNEL);
232 	if (!entry)
233 		return 0;
234 
235 	memcpy(entry->var.VariableName, name, name_size);
236 	memcpy(&entry->var.VendorGuid, &vendor, sizeof(efi_guid_t));
237 
238 	efivar_entry_add(entry, list);
239 
240 	return 0;
241 }
242 
243 static __init int efivar_ssdt_load(void)
244 {
245 	LIST_HEAD(entries);
246 	struct efivar_entry *entry, *aux;
247 	unsigned long size;
248 	void *data;
249 	int ret;
250 
251 	ret = efivar_init(efivar_ssdt_iter, &entries, true, &entries);
252 
253 	list_for_each_entry_safe(entry, aux, &entries, list) {
254 		pr_info("loading SSDT from variable %s-%pUl\n", efivar_ssdt,
255 			&entry->var.VendorGuid);
256 
257 		list_del(&entry->list);
258 
259 		ret = efivar_entry_size(entry, &size);
260 		if (ret) {
261 			pr_err("failed to get var size\n");
262 			goto free_entry;
263 		}
264 
265 		data = kmalloc(size, GFP_KERNEL);
266 		if (!data) {
267 			ret = -ENOMEM;
268 			goto free_entry;
269 		}
270 
271 		ret = efivar_entry_get(entry, NULL, &size, data);
272 		if (ret) {
273 			pr_err("failed to get var data\n");
274 			goto free_data;
275 		}
276 
277 		ret = acpi_load_table(data);
278 		if (ret) {
279 			pr_err("failed to load table: %d\n", ret);
280 			goto free_data;
281 		}
282 
283 		goto free_entry;
284 
285 free_data:
286 		kfree(data);
287 
288 free_entry:
289 		kfree(entry);
290 	}
291 
292 	return ret;
293 }
294 #else
295 static inline int efivar_ssdt_load(void) { return 0; }
296 #endif
297 
298 /*
299  * We register the efi subsystem with the firmware subsystem and the
300  * efivars subsystem with the efi subsystem, if the system was booted with
301  * EFI.
302  */
303 static int __init efisubsys_init(void)
304 {
305 	int error;
306 
307 	if (!efi_enabled(EFI_BOOT))
308 		return 0;
309 
310 	/* We register the efi directory at /sys/firmware/efi */
311 	efi_kobj = kobject_create_and_add("efi", firmware_kobj);
312 	if (!efi_kobj) {
313 		pr_err("efi: Firmware registration failed.\n");
314 		return -ENOMEM;
315 	}
316 
317 	error = generic_ops_register();
318 	if (error)
319 		goto err_put;
320 
321 	if (efi_enabled(EFI_RUNTIME_SERVICES))
322 		efivar_ssdt_load();
323 
324 	error = sysfs_create_group(efi_kobj, &efi_subsys_attr_group);
325 	if (error) {
326 		pr_err("efi: Sysfs attribute export failed with error %d.\n",
327 		       error);
328 		goto err_unregister;
329 	}
330 
331 	error = efi_runtime_map_init(efi_kobj);
332 	if (error)
333 		goto err_remove_group;
334 
335 	/* and the standard mountpoint for efivarfs */
336 	error = sysfs_create_mount_point(efi_kobj, "efivars");
337 	if (error) {
338 		pr_err("efivars: Subsystem registration failed.\n");
339 		goto err_remove_group;
340 	}
341 
342 	return 0;
343 
344 err_remove_group:
345 	sysfs_remove_group(efi_kobj, &efi_subsys_attr_group);
346 err_unregister:
347 	generic_ops_unregister();
348 err_put:
349 	kobject_put(efi_kobj);
350 	return error;
351 }
352 
353 subsys_initcall(efisubsys_init);
354 
355 /*
356  * Find the efi memory descriptor for a given physical address.  Given a
357  * physical address, determine if it exists within an EFI Memory Map entry,
358  * and if so, populate the supplied memory descriptor with the appropriate
359  * data.
360  */
361 int __init efi_mem_desc_lookup(u64 phys_addr, efi_memory_desc_t *out_md)
362 {
363 	efi_memory_desc_t *md;
364 
365 	if (!efi_enabled(EFI_MEMMAP)) {
366 		pr_err_once("EFI_MEMMAP is not enabled.\n");
367 		return -EINVAL;
368 	}
369 
370 	if (!out_md) {
371 		pr_err_once("out_md is null.\n");
372 		return -EINVAL;
373         }
374 
375 	for_each_efi_memory_desc(md) {
376 		u64 size;
377 		u64 end;
378 
379 		if (!(md->attribute & EFI_MEMORY_RUNTIME) &&
380 		    md->type != EFI_BOOT_SERVICES_DATA &&
381 		    md->type != EFI_RUNTIME_SERVICES_DATA) {
382 			continue;
383 		}
384 
385 		size = md->num_pages << EFI_PAGE_SHIFT;
386 		end = md->phys_addr + size;
387 		if (phys_addr >= md->phys_addr && phys_addr < end) {
388 			memcpy(out_md, md, sizeof(*out_md));
389 			return 0;
390 		}
391 	}
392 	return -ENOENT;
393 }
394 
395 /*
396  * Calculate the highest address of an efi memory descriptor.
397  */
398 u64 __init efi_mem_desc_end(efi_memory_desc_t *md)
399 {
400 	u64 size = md->num_pages << EFI_PAGE_SHIFT;
401 	u64 end = md->phys_addr + size;
402 	return end;
403 }
404 
405 void __init __weak efi_arch_mem_reserve(phys_addr_t addr, u64 size) {}
406 
407 /**
408  * efi_mem_reserve - Reserve an EFI memory region
409  * @addr: Physical address to reserve
410  * @size: Size of reservation
411  *
412  * Mark a region as reserved from general kernel allocation and
413  * prevent it being released by efi_free_boot_services().
414  *
415  * This function should be called drivers once they've parsed EFI
416  * configuration tables to figure out where their data lives, e.g.
417  * efi_esrt_init().
418  */
419 void __init efi_mem_reserve(phys_addr_t addr, u64 size)
420 {
421 	if (!memblock_is_region_reserved(addr, size))
422 		memblock_reserve(addr, size);
423 
424 	/*
425 	 * Some architectures (x86) reserve all boot services ranges
426 	 * until efi_free_boot_services() because of buggy firmware
427 	 * implementations. This means the above memblock_reserve() is
428 	 * superfluous on x86 and instead what it needs to do is
429 	 * ensure the @start, @size is not freed.
430 	 */
431 	efi_arch_mem_reserve(addr, size);
432 }
433 
434 static __initdata efi_config_table_type_t common_tables[] = {
435 	{ACPI_20_TABLE_GUID, "ACPI 2.0", &efi.acpi20},
436 	{ACPI_TABLE_GUID, "ACPI", &efi.acpi},
437 	{HCDP_TABLE_GUID, "HCDP", &efi.hcdp},
438 	{MPS_TABLE_GUID, "MPS", &efi.mps},
439 	{SAL_SYSTEM_TABLE_GUID, "SALsystab", &efi.sal_systab},
440 	{SMBIOS_TABLE_GUID, "SMBIOS", &efi.smbios},
441 	{SMBIOS3_TABLE_GUID, "SMBIOS 3.0", &efi.smbios3},
442 	{UGA_IO_PROTOCOL_GUID, "UGA", &efi.uga},
443 	{EFI_SYSTEM_RESOURCE_TABLE_GUID, "ESRT", &efi.esrt},
444 	{EFI_PROPERTIES_TABLE_GUID, "PROP", &efi.properties_table},
445 	{EFI_MEMORY_ATTRIBUTES_TABLE_GUID, "MEMATTR", &efi.mem_attr_table},
446 	{LINUX_EFI_RANDOM_SEED_TABLE_GUID, "RNG", &efi.rng_seed},
447 	{NULL_GUID, NULL, NULL},
448 };
449 
450 static __init int match_config_table(efi_guid_t *guid,
451 				     unsigned long table,
452 				     efi_config_table_type_t *table_types)
453 {
454 	int i;
455 
456 	if (table_types) {
457 		for (i = 0; efi_guidcmp(table_types[i].guid, NULL_GUID); i++) {
458 			if (!efi_guidcmp(*guid, table_types[i].guid)) {
459 				*(table_types[i].ptr) = table;
460 				if (table_types[i].name)
461 					pr_cont(" %s=0x%lx ",
462 						table_types[i].name, table);
463 				return 1;
464 			}
465 		}
466 	}
467 
468 	return 0;
469 }
470 
471 int __init efi_config_parse_tables(void *config_tables, int count, int sz,
472 				   efi_config_table_type_t *arch_tables)
473 {
474 	void *tablep;
475 	int i;
476 
477 	tablep = config_tables;
478 	pr_info("");
479 	for (i = 0; i < count; i++) {
480 		efi_guid_t guid;
481 		unsigned long table;
482 
483 		if (efi_enabled(EFI_64BIT)) {
484 			u64 table64;
485 			guid = ((efi_config_table_64_t *)tablep)->guid;
486 			table64 = ((efi_config_table_64_t *)tablep)->table;
487 			table = table64;
488 #ifndef CONFIG_64BIT
489 			if (table64 >> 32) {
490 				pr_cont("\n");
491 				pr_err("Table located above 4GB, disabling EFI.\n");
492 				return -EINVAL;
493 			}
494 #endif
495 		} else {
496 			guid = ((efi_config_table_32_t *)tablep)->guid;
497 			table = ((efi_config_table_32_t *)tablep)->table;
498 		}
499 
500 		if (!match_config_table(&guid, table, common_tables))
501 			match_config_table(&guid, table, arch_tables);
502 
503 		tablep += sz;
504 	}
505 	pr_cont("\n");
506 	set_bit(EFI_CONFIG_TABLES, &efi.flags);
507 
508 	if (efi.rng_seed != EFI_INVALID_TABLE_ADDR) {
509 		struct linux_efi_random_seed *seed;
510 		u32 size = 0;
511 
512 		seed = early_memremap(efi.rng_seed, sizeof(*seed));
513 		if (seed != NULL) {
514 			size = seed->size;
515 			early_memunmap(seed, sizeof(*seed));
516 		} else {
517 			pr_err("Could not map UEFI random seed!\n");
518 		}
519 		if (size > 0) {
520 			seed = early_memremap(efi.rng_seed,
521 					      sizeof(*seed) + size);
522 			if (seed != NULL) {
523 				add_device_randomness(seed->bits, seed->size);
524 				early_memunmap(seed, sizeof(*seed) + size);
525 			} else {
526 				pr_err("Could not map UEFI random seed!\n");
527 			}
528 		}
529 	}
530 
531 	if (efi_enabled(EFI_MEMMAP))
532 		efi_memattr_init();
533 
534 	/* Parse the EFI Properties table if it exists */
535 	if (efi.properties_table != EFI_INVALID_TABLE_ADDR) {
536 		efi_properties_table_t *tbl;
537 
538 		tbl = early_memremap(efi.properties_table, sizeof(*tbl));
539 		if (tbl == NULL) {
540 			pr_err("Could not map Properties table!\n");
541 			return -ENOMEM;
542 		}
543 
544 		if (tbl->memory_protection_attribute &
545 		    EFI_PROPERTIES_RUNTIME_MEMORY_PROTECTION_NON_EXECUTABLE_PE_DATA)
546 			set_bit(EFI_NX_PE_DATA, &efi.flags);
547 
548 		early_memunmap(tbl, sizeof(*tbl));
549 	}
550 
551 	return 0;
552 }
553 
554 int __init efi_config_init(efi_config_table_type_t *arch_tables)
555 {
556 	void *config_tables;
557 	int sz, ret;
558 
559 	if (efi_enabled(EFI_64BIT))
560 		sz = sizeof(efi_config_table_64_t);
561 	else
562 		sz = sizeof(efi_config_table_32_t);
563 
564 	/*
565 	 * Let's see what config tables the firmware passed to us.
566 	 */
567 	config_tables = early_memremap(efi.systab->tables,
568 				       efi.systab->nr_tables * sz);
569 	if (config_tables == NULL) {
570 		pr_err("Could not map Configuration table!\n");
571 		return -ENOMEM;
572 	}
573 
574 	ret = efi_config_parse_tables(config_tables, efi.systab->nr_tables, sz,
575 				      arch_tables);
576 
577 	early_memunmap(config_tables, efi.systab->nr_tables * sz);
578 	return ret;
579 }
580 
581 #ifdef CONFIG_EFI_VARS_MODULE
582 static int __init efi_load_efivars(void)
583 {
584 	struct platform_device *pdev;
585 
586 	if (!efi_enabled(EFI_RUNTIME_SERVICES))
587 		return 0;
588 
589 	pdev = platform_device_register_simple("efivars", 0, NULL, 0);
590 	return IS_ERR(pdev) ? PTR_ERR(pdev) : 0;
591 }
592 device_initcall(efi_load_efivars);
593 #endif
594 
595 #ifdef CONFIG_EFI_PARAMS_FROM_FDT
596 
597 #define UEFI_PARAM(name, prop, field)			   \
598 	{						   \
599 		{ name },				   \
600 		{ prop },				   \
601 		offsetof(struct efi_fdt_params, field),    \
602 		FIELD_SIZEOF(struct efi_fdt_params, field) \
603 	}
604 
605 struct params {
606 	const char name[32];
607 	const char propname[32];
608 	int offset;
609 	int size;
610 };
611 
612 static __initdata struct params fdt_params[] = {
613 	UEFI_PARAM("System Table", "linux,uefi-system-table", system_table),
614 	UEFI_PARAM("MemMap Address", "linux,uefi-mmap-start", mmap),
615 	UEFI_PARAM("MemMap Size", "linux,uefi-mmap-size", mmap_size),
616 	UEFI_PARAM("MemMap Desc. Size", "linux,uefi-mmap-desc-size", desc_size),
617 	UEFI_PARAM("MemMap Desc. Version", "linux,uefi-mmap-desc-ver", desc_ver)
618 };
619 
620 static __initdata struct params xen_fdt_params[] = {
621 	UEFI_PARAM("System Table", "xen,uefi-system-table", system_table),
622 	UEFI_PARAM("MemMap Address", "xen,uefi-mmap-start", mmap),
623 	UEFI_PARAM("MemMap Size", "xen,uefi-mmap-size", mmap_size),
624 	UEFI_PARAM("MemMap Desc. Size", "xen,uefi-mmap-desc-size", desc_size),
625 	UEFI_PARAM("MemMap Desc. Version", "xen,uefi-mmap-desc-ver", desc_ver)
626 };
627 
628 #define EFI_FDT_PARAMS_SIZE	ARRAY_SIZE(fdt_params)
629 
630 static __initdata struct {
631 	const char *uname;
632 	const char *subnode;
633 	struct params *params;
634 } dt_params[] = {
635 	{ "hypervisor", "uefi", xen_fdt_params },
636 	{ "chosen", NULL, fdt_params },
637 };
638 
639 struct param_info {
640 	int found;
641 	void *params;
642 	const char *missing;
643 };
644 
645 static int __init __find_uefi_params(unsigned long node,
646 				     struct param_info *info,
647 				     struct params *params)
648 {
649 	const void *prop;
650 	void *dest;
651 	u64 val;
652 	int i, len;
653 
654 	for (i = 0; i < EFI_FDT_PARAMS_SIZE; i++) {
655 		prop = of_get_flat_dt_prop(node, params[i].propname, &len);
656 		if (!prop) {
657 			info->missing = params[i].name;
658 			return 0;
659 		}
660 
661 		dest = info->params + params[i].offset;
662 		info->found++;
663 
664 		val = of_read_number(prop, len / sizeof(u32));
665 
666 		if (params[i].size == sizeof(u32))
667 			*(u32 *)dest = val;
668 		else
669 			*(u64 *)dest = val;
670 
671 		if (efi_enabled(EFI_DBG))
672 			pr_info("  %s: 0x%0*llx\n", params[i].name,
673 				params[i].size * 2, val);
674 	}
675 
676 	return 1;
677 }
678 
679 static int __init fdt_find_uefi_params(unsigned long node, const char *uname,
680 				       int depth, void *data)
681 {
682 	struct param_info *info = data;
683 	int i;
684 
685 	for (i = 0; i < ARRAY_SIZE(dt_params); i++) {
686 		const char *subnode = dt_params[i].subnode;
687 
688 		if (depth != 1 || strcmp(uname, dt_params[i].uname) != 0) {
689 			info->missing = dt_params[i].params[0].name;
690 			continue;
691 		}
692 
693 		if (subnode) {
694 			int err = of_get_flat_dt_subnode_by_name(node, subnode);
695 
696 			if (err < 0)
697 				return 0;
698 
699 			node = err;
700 		}
701 
702 		return __find_uefi_params(node, info, dt_params[i].params);
703 	}
704 
705 	return 0;
706 }
707 
708 int __init efi_get_fdt_params(struct efi_fdt_params *params)
709 {
710 	struct param_info info;
711 	int ret;
712 
713 	pr_info("Getting EFI parameters from FDT:\n");
714 
715 	info.found = 0;
716 	info.params = params;
717 
718 	ret = of_scan_flat_dt(fdt_find_uefi_params, &info);
719 	if (!info.found)
720 		pr_info("UEFI not found.\n");
721 	else if (!ret)
722 		pr_err("Can't find '%s' in device tree!\n",
723 		       info.missing);
724 
725 	return ret;
726 }
727 #endif /* CONFIG_EFI_PARAMS_FROM_FDT */
728 
729 static __initdata char memory_type_name[][20] = {
730 	"Reserved",
731 	"Loader Code",
732 	"Loader Data",
733 	"Boot Code",
734 	"Boot Data",
735 	"Runtime Code",
736 	"Runtime Data",
737 	"Conventional Memory",
738 	"Unusable Memory",
739 	"ACPI Reclaim Memory",
740 	"ACPI Memory NVS",
741 	"Memory Mapped I/O",
742 	"MMIO Port Space",
743 	"PAL Code",
744 	"Persistent Memory",
745 };
746 
747 char * __init efi_md_typeattr_format(char *buf, size_t size,
748 				     const efi_memory_desc_t *md)
749 {
750 	char *pos;
751 	int type_len;
752 	u64 attr;
753 
754 	pos = buf;
755 	if (md->type >= ARRAY_SIZE(memory_type_name))
756 		type_len = snprintf(pos, size, "[type=%u", md->type);
757 	else
758 		type_len = snprintf(pos, size, "[%-*s",
759 				    (int)(sizeof(memory_type_name[0]) - 1),
760 				    memory_type_name[md->type]);
761 	if (type_len >= size)
762 		return buf;
763 
764 	pos += type_len;
765 	size -= type_len;
766 
767 	attr = md->attribute;
768 	if (attr & ~(EFI_MEMORY_UC | EFI_MEMORY_WC | EFI_MEMORY_WT |
769 		     EFI_MEMORY_WB | EFI_MEMORY_UCE | EFI_MEMORY_RO |
770 		     EFI_MEMORY_WP | EFI_MEMORY_RP | EFI_MEMORY_XP |
771 		     EFI_MEMORY_NV |
772 		     EFI_MEMORY_RUNTIME | EFI_MEMORY_MORE_RELIABLE))
773 		snprintf(pos, size, "|attr=0x%016llx]",
774 			 (unsigned long long)attr);
775 	else
776 		snprintf(pos, size,
777 			 "|%3s|%2s|%2s|%2s|%2s|%2s|%2s|%3s|%2s|%2s|%2s|%2s]",
778 			 attr & EFI_MEMORY_RUNTIME ? "RUN" : "",
779 			 attr & EFI_MEMORY_MORE_RELIABLE ? "MR" : "",
780 			 attr & EFI_MEMORY_NV      ? "NV"  : "",
781 			 attr & EFI_MEMORY_XP      ? "XP"  : "",
782 			 attr & EFI_MEMORY_RP      ? "RP"  : "",
783 			 attr & EFI_MEMORY_WP      ? "WP"  : "",
784 			 attr & EFI_MEMORY_RO      ? "RO"  : "",
785 			 attr & EFI_MEMORY_UCE     ? "UCE" : "",
786 			 attr & EFI_MEMORY_WB      ? "WB"  : "",
787 			 attr & EFI_MEMORY_WT      ? "WT"  : "",
788 			 attr & EFI_MEMORY_WC      ? "WC"  : "",
789 			 attr & EFI_MEMORY_UC      ? "UC"  : "");
790 	return buf;
791 }
792 
793 /*
794  * efi_mem_attributes - lookup memmap attributes for physical address
795  * @phys_addr: the physical address to lookup
796  *
797  * Search in the EFI memory map for the region covering
798  * @phys_addr. Returns the EFI memory attributes if the region
799  * was found in the memory map, 0 otherwise.
800  *
801  * Despite being marked __weak, most architectures should *not*
802  * override this function. It is __weak solely for the benefit
803  * of ia64 which has a funky EFI memory map that doesn't work
804  * the same way as other architectures.
805  */
806 u64 __weak efi_mem_attributes(unsigned long phys_addr)
807 {
808 	efi_memory_desc_t *md;
809 
810 	if (!efi_enabled(EFI_MEMMAP))
811 		return 0;
812 
813 	for_each_efi_memory_desc(md) {
814 		if ((md->phys_addr <= phys_addr) &&
815 		    (phys_addr < (md->phys_addr +
816 		    (md->num_pages << EFI_PAGE_SHIFT))))
817 			return md->attribute;
818 	}
819 	return 0;
820 }
821 
822 int efi_status_to_err(efi_status_t status)
823 {
824 	int err;
825 
826 	switch (status) {
827 	case EFI_SUCCESS:
828 		err = 0;
829 		break;
830 	case EFI_INVALID_PARAMETER:
831 		err = -EINVAL;
832 		break;
833 	case EFI_OUT_OF_RESOURCES:
834 		err = -ENOSPC;
835 		break;
836 	case EFI_DEVICE_ERROR:
837 		err = -EIO;
838 		break;
839 	case EFI_WRITE_PROTECTED:
840 		err = -EROFS;
841 		break;
842 	case EFI_SECURITY_VIOLATION:
843 		err = -EACCES;
844 		break;
845 	case EFI_NOT_FOUND:
846 		err = -ENOENT;
847 		break;
848 	case EFI_ABORTED:
849 		err = -EINTR;
850 		break;
851 	default:
852 		err = -EINVAL;
853 	}
854 
855 	return err;
856 }
857 
858 #ifdef CONFIG_KEXEC
859 static int update_efi_random_seed(struct notifier_block *nb,
860 				  unsigned long code, void *unused)
861 {
862 	struct linux_efi_random_seed *seed;
863 	u32 size = 0;
864 
865 	if (!kexec_in_progress)
866 		return NOTIFY_DONE;
867 
868 	seed = memremap(efi.rng_seed, sizeof(*seed), MEMREMAP_WB);
869 	if (seed != NULL) {
870 		size = min(seed->size, 32U);
871 		memunmap(seed);
872 	} else {
873 		pr_err("Could not map UEFI random seed!\n");
874 	}
875 	if (size > 0) {
876 		seed = memremap(efi.rng_seed, sizeof(*seed) + size,
877 				MEMREMAP_WB);
878 		if (seed != NULL) {
879 			seed->size = size;
880 			get_random_bytes(seed->bits, seed->size);
881 			memunmap(seed);
882 		} else {
883 			pr_err("Could not map UEFI random seed!\n");
884 		}
885 	}
886 	return NOTIFY_DONE;
887 }
888 
889 static struct notifier_block efi_random_seed_nb = {
890 	.notifier_call = update_efi_random_seed,
891 };
892 
893 static int register_update_efi_random_seed(void)
894 {
895 	if (efi.rng_seed == EFI_INVALID_TABLE_ADDR)
896 		return 0;
897 	return register_reboot_notifier(&efi_random_seed_nb);
898 }
899 late_initcall(register_update_efi_random_seed);
900 #endif
901