xref: /openbmc/linux/drivers/firmware/efi/efi.c (revision f7d84fa7) 
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 	efi_memattr_init();
532 
533 	/* Parse the EFI Properties table if it exists */
534 	if (efi.properties_table != EFI_INVALID_TABLE_ADDR) {
535 		efi_properties_table_t *tbl;
536 
537 		tbl = early_memremap(efi.properties_table, sizeof(*tbl));
538 		if (tbl == NULL) {
539 			pr_err("Could not map Properties table!\n");
540 			return -ENOMEM;
541 		}
542 
543 		if (tbl->memory_protection_attribute &
544 		    EFI_PROPERTIES_RUNTIME_MEMORY_PROTECTION_NON_EXECUTABLE_PE_DATA)
545 			set_bit(EFI_NX_PE_DATA, &efi.flags);
546 
547 		early_memunmap(tbl, sizeof(*tbl));
548 	}
549 
550 	return 0;
551 }
552 
553 int __init efi_config_init(efi_config_table_type_t *arch_tables)
554 {
555 	void *config_tables;
556 	int sz, ret;
557 
558 	if (efi_enabled(EFI_64BIT))
559 		sz = sizeof(efi_config_table_64_t);
560 	else
561 		sz = sizeof(efi_config_table_32_t);
562 
563 	/*
564 	 * Let's see what config tables the firmware passed to us.
565 	 */
566 	config_tables = early_memremap(efi.systab->tables,
567 				       efi.systab->nr_tables * sz);
568 	if (config_tables == NULL) {
569 		pr_err("Could not map Configuration table!\n");
570 		return -ENOMEM;
571 	}
572 
573 	ret = efi_config_parse_tables(config_tables, efi.systab->nr_tables, sz,
574 				      arch_tables);
575 
576 	early_memunmap(config_tables, efi.systab->nr_tables * sz);
577 	return ret;
578 }
579 
580 #ifdef CONFIG_EFI_VARS_MODULE
581 static int __init efi_load_efivars(void)
582 {
583 	struct platform_device *pdev;
584 
585 	if (!efi_enabled(EFI_RUNTIME_SERVICES))
586 		return 0;
587 
588 	pdev = platform_device_register_simple("efivars", 0, NULL, 0);
589 	return IS_ERR(pdev) ? PTR_ERR(pdev) : 0;
590 }
591 device_initcall(efi_load_efivars);
592 #endif
593 
594 #ifdef CONFIG_EFI_PARAMS_FROM_FDT
595 
596 #define UEFI_PARAM(name, prop, field)			   \
597 	{						   \
598 		{ name },				   \
599 		{ prop },				   \
600 		offsetof(struct efi_fdt_params, field),    \
601 		FIELD_SIZEOF(struct efi_fdt_params, field) \
602 	}
603 
604 struct params {
605 	const char name[32];
606 	const char propname[32];
607 	int offset;
608 	int size;
609 };
610 
611 static __initdata struct params fdt_params[] = {
612 	UEFI_PARAM("System Table", "linux,uefi-system-table", system_table),
613 	UEFI_PARAM("MemMap Address", "linux,uefi-mmap-start", mmap),
614 	UEFI_PARAM("MemMap Size", "linux,uefi-mmap-size", mmap_size),
615 	UEFI_PARAM("MemMap Desc. Size", "linux,uefi-mmap-desc-size", desc_size),
616 	UEFI_PARAM("MemMap Desc. Version", "linux,uefi-mmap-desc-ver", desc_ver)
617 };
618 
619 static __initdata struct params xen_fdt_params[] = {
620 	UEFI_PARAM("System Table", "xen,uefi-system-table", system_table),
621 	UEFI_PARAM("MemMap Address", "xen,uefi-mmap-start", mmap),
622 	UEFI_PARAM("MemMap Size", "xen,uefi-mmap-size", mmap_size),
623 	UEFI_PARAM("MemMap Desc. Size", "xen,uefi-mmap-desc-size", desc_size),
624 	UEFI_PARAM("MemMap Desc. Version", "xen,uefi-mmap-desc-ver", desc_ver)
625 };
626 
627 #define EFI_FDT_PARAMS_SIZE	ARRAY_SIZE(fdt_params)
628 
629 static __initdata struct {
630 	const char *uname;
631 	const char *subnode;
632 	struct params *params;
633 } dt_params[] = {
634 	{ "hypervisor", "uefi", xen_fdt_params },
635 	{ "chosen", NULL, fdt_params },
636 };
637 
638 struct param_info {
639 	int found;
640 	void *params;
641 	const char *missing;
642 };
643 
644 static int __init __find_uefi_params(unsigned long node,
645 				     struct param_info *info,
646 				     struct params *params)
647 {
648 	const void *prop;
649 	void *dest;
650 	u64 val;
651 	int i, len;
652 
653 	for (i = 0; i < EFI_FDT_PARAMS_SIZE; i++) {
654 		prop = of_get_flat_dt_prop(node, params[i].propname, &len);
655 		if (!prop) {
656 			info->missing = params[i].name;
657 			return 0;
658 		}
659 
660 		dest = info->params + params[i].offset;
661 		info->found++;
662 
663 		val = of_read_number(prop, len / sizeof(u32));
664 
665 		if (params[i].size == sizeof(u32))
666 			*(u32 *)dest = val;
667 		else
668 			*(u64 *)dest = val;
669 
670 		if (efi_enabled(EFI_DBG))
671 			pr_info("  %s: 0x%0*llx\n", params[i].name,
672 				params[i].size * 2, val);
673 	}
674 
675 	return 1;
676 }
677 
678 static int __init fdt_find_uefi_params(unsigned long node, const char *uname,
679 				       int depth, void *data)
680 {
681 	struct param_info *info = data;
682 	int i;
683 
684 	for (i = 0; i < ARRAY_SIZE(dt_params); i++) {
685 		const char *subnode = dt_params[i].subnode;
686 
687 		if (depth != 1 || strcmp(uname, dt_params[i].uname) != 0) {
688 			info->missing = dt_params[i].params[0].name;
689 			continue;
690 		}
691 
692 		if (subnode) {
693 			int err = of_get_flat_dt_subnode_by_name(node, subnode);
694 
695 			if (err < 0)
696 				return 0;
697 
698 			node = err;
699 		}
700 
701 		return __find_uefi_params(node, info, dt_params[i].params);
702 	}
703 
704 	return 0;
705 }
706 
707 int __init efi_get_fdt_params(struct efi_fdt_params *params)
708 {
709 	struct param_info info;
710 	int ret;
711 
712 	pr_info("Getting EFI parameters from FDT:\n");
713 
714 	info.found = 0;
715 	info.params = params;
716 
717 	ret = of_scan_flat_dt(fdt_find_uefi_params, &info);
718 	if (!info.found)
719 		pr_info("UEFI not found.\n");
720 	else if (!ret)
721 		pr_err("Can't find '%s' in device tree!\n",
722 		       info.missing);
723 
724 	return ret;
725 }
726 #endif /* CONFIG_EFI_PARAMS_FROM_FDT */
727 
728 static __initdata char memory_type_name[][20] = {
729 	"Reserved",
730 	"Loader Code",
731 	"Loader Data",
732 	"Boot Code",
733 	"Boot Data",
734 	"Runtime Code",
735 	"Runtime Data",
736 	"Conventional Memory",
737 	"Unusable Memory",
738 	"ACPI Reclaim Memory",
739 	"ACPI Memory NVS",
740 	"Memory Mapped I/O",
741 	"MMIO Port Space",
742 	"PAL Code",
743 	"Persistent Memory",
744 };
745 
746 char * __init efi_md_typeattr_format(char *buf, size_t size,
747 				     const efi_memory_desc_t *md)
748 {
749 	char *pos;
750 	int type_len;
751 	u64 attr;
752 
753 	pos = buf;
754 	if (md->type >= ARRAY_SIZE(memory_type_name))
755 		type_len = snprintf(pos, size, "[type=%u", md->type);
756 	else
757 		type_len = snprintf(pos, size, "[%-*s",
758 				    (int)(sizeof(memory_type_name[0]) - 1),
759 				    memory_type_name[md->type]);
760 	if (type_len >= size)
761 		return buf;
762 
763 	pos += type_len;
764 	size -= type_len;
765 
766 	attr = md->attribute;
767 	if (attr & ~(EFI_MEMORY_UC | EFI_MEMORY_WC | EFI_MEMORY_WT |
768 		     EFI_MEMORY_WB | EFI_MEMORY_UCE | EFI_MEMORY_RO |
769 		     EFI_MEMORY_WP | EFI_MEMORY_RP | EFI_MEMORY_XP |
770 		     EFI_MEMORY_NV |
771 		     EFI_MEMORY_RUNTIME | EFI_MEMORY_MORE_RELIABLE))
772 		snprintf(pos, size, "|attr=0x%016llx]",
773 			 (unsigned long long)attr);
774 	else
775 		snprintf(pos, size,
776 			 "|%3s|%2s|%2s|%2s|%2s|%2s|%2s|%3s|%2s|%2s|%2s|%2s]",
777 			 attr & EFI_MEMORY_RUNTIME ? "RUN" : "",
778 			 attr & EFI_MEMORY_MORE_RELIABLE ? "MR" : "",
779 			 attr & EFI_MEMORY_NV      ? "NV"  : "",
780 			 attr & EFI_MEMORY_XP      ? "XP"  : "",
781 			 attr & EFI_MEMORY_RP      ? "RP"  : "",
782 			 attr & EFI_MEMORY_WP      ? "WP"  : "",
783 			 attr & EFI_MEMORY_RO      ? "RO"  : "",
784 			 attr & EFI_MEMORY_UCE     ? "UCE" : "",
785 			 attr & EFI_MEMORY_WB      ? "WB"  : "",
786 			 attr & EFI_MEMORY_WT      ? "WT"  : "",
787 			 attr & EFI_MEMORY_WC      ? "WC"  : "",
788 			 attr & EFI_MEMORY_UC      ? "UC"  : "");
789 	return buf;
790 }
791 
792 /*
793  * efi_mem_attributes - lookup memmap attributes for physical address
794  * @phys_addr: the physical address to lookup
795  *
796  * Search in the EFI memory map for the region covering
797  * @phys_addr. Returns the EFI memory attributes if the region
798  * was found in the memory map, 0 otherwise.
799  *
800  * Despite being marked __weak, most architectures should *not*
801  * override this function. It is __weak solely for the benefit
802  * of ia64 which has a funky EFI memory map that doesn't work
803  * the same way as other architectures.
804  */
805 u64 __weak efi_mem_attributes(unsigned long phys_addr)
806 {
807 	efi_memory_desc_t *md;
808 
809 	if (!efi_enabled(EFI_MEMMAP))
810 		return 0;
811 
812 	for_each_efi_memory_desc(md) {
813 		if ((md->phys_addr <= phys_addr) &&
814 		    (phys_addr < (md->phys_addr +
815 		    (md->num_pages << EFI_PAGE_SHIFT))))
816 			return md->attribute;
817 	}
818 	return 0;
819 }
820 
821 int efi_status_to_err(efi_status_t status)
822 {
823 	int err;
824 
825 	switch (status) {
826 	case EFI_SUCCESS:
827 		err = 0;
828 		break;
829 	case EFI_INVALID_PARAMETER:
830 		err = -EINVAL;
831 		break;
832 	case EFI_OUT_OF_RESOURCES:
833 		err = -ENOSPC;
834 		break;
835 	case EFI_DEVICE_ERROR:
836 		err = -EIO;
837 		break;
838 	case EFI_WRITE_PROTECTED:
839 		err = -EROFS;
840 		break;
841 	case EFI_SECURITY_VIOLATION:
842 		err = -EACCES;
843 		break;
844 	case EFI_NOT_FOUND:
845 		err = -ENOENT;
846 		break;
847 	case EFI_ABORTED:
848 		err = -EINTR;
849 		break;
850 	default:
851 		err = -EINVAL;
852 	}
853 
854 	return err;
855 }
856 
857 #ifdef CONFIG_KEXEC
858 static int update_efi_random_seed(struct notifier_block *nb,
859 				  unsigned long code, void *unused)
860 {
861 	struct linux_efi_random_seed *seed;
862 	u32 size = 0;
863 
864 	if (!kexec_in_progress)
865 		return NOTIFY_DONE;
866 
867 	seed = memremap(efi.rng_seed, sizeof(*seed), MEMREMAP_WB);
868 	if (seed != NULL) {
869 		size = min(seed->size, 32U);
870 		memunmap(seed);
871 	} else {
872 		pr_err("Could not map UEFI random seed!\n");
873 	}
874 	if (size > 0) {
875 		seed = memremap(efi.rng_seed, sizeof(*seed) + size,
876 				MEMREMAP_WB);
877 		if (seed != NULL) {
878 			seed->size = size;
879 			get_random_bytes(seed->bits, seed->size);
880 			memunmap(seed);
881 		} else {
882 			pr_err("Could not map UEFI random seed!\n");
883 		}
884 	}
885 	return NOTIFY_DONE;
886 }
887 
888 static struct notifier_block efi_random_seed_nb = {
889 	.notifier_call = update_efi_random_seed,
890 };
891 
892 static int register_update_efi_random_seed(void)
893 {
894 	if (efi.rng_seed == EFI_INVALID_TABLE_ADDR)
895 		return 0;
896 	return register_reboot_notifier(&efi_random_seed_nb);
897 }
898 late_initcall(register_update_efi_random_seed);
899 #endif
900