~hc/RK356X_SDK_RELEASE.git

..	..	@@ -1,3 +1,4 @@
	1	+// SPDX-License-Identifier: GPL-2.0-only
1	2	/*
2	3	* efi.c - EFI subsystem
3	4	*
..	..	@@ -9,8 +10,6 @@
9	10	* allowing the efivarfs to be mounted or the efivars module to be loaded.
10	11	* The existance of /sys/firmware/efi may also be used by userspace to
11	12	* determine that the system supports EFI.
12		- *
13		- * This file is released under the GPLv2.
14	13	*/
15	14
16	15	#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
..	..	@@ -18,10 +17,10 @@
18	17	#include <linux/kobject.h>
19	18	#include <linux/module.h>
20	19	#include <linux/init.h>
	20	+#include <linux/debugfs.h>
21	21	#include <linux/device.h>
22	22	#include <linux/efi.h>
23	23	#include <linux/of.h>
24		-#include <linux/of_fdt.h>
25	24	#include <linux/io.h>
26	25	#include <linux/kexec.h>
27	26	#include <linux/platform_device.h>
..	..	@@ -31,55 +30,35 @@
31	30	#include <linux/acpi.h>
32	31	#include <linux/ucs2_string.h>
33	32	#include <linux/memblock.h>
	33	+#include <linux/security.h>
34	34
35	35	#include <asm/early_ioremap.h>
36	36
37	37	struct efi __read_mostly efi = {
38		- .mps = EFI_INVALID_TABLE_ADDR,
	38	+ .runtime_supported_mask = EFI_RT_SUPPORTED_ALL,
39	39	.acpi = EFI_INVALID_TABLE_ADDR,
40	40	.acpi20 = EFI_INVALID_TABLE_ADDR,
41	41	.smbios = EFI_INVALID_TABLE_ADDR,
42	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	43	.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
	44	+ .tpm_log = EFI_INVALID_TABLE_ADDR,
	45	+ .tpm_final_log = EFI_INVALID_TABLE_ADDR,
	46	+#ifdef CONFIG_LOAD_UEFI_KEYS
	47	+ .mokvar_table = EFI_INVALID_TABLE_ADDR,
	48	+#endif
56	49	};
57	50	EXPORT_SYMBOL(efi);
58	51
59		-static unsigned long *efi_tables[] = {
60		- &efi.mps,
61		- &efi.acpi,
62		- &efi.acpi20,
63		- &efi.smbios,
64		- &efi.smbios3,
65		- &efi.sal_systab,
66		- &efi.boot_info,
67		- &efi.hcdp,
68		- &efi.uga,
69		- &efi.uv_systab,
70		- &efi.fw_vendor,
71		- &efi.runtime,
72		- &efi.config_table,
73		- &efi.esrt,
74		- &efi.properties_table,
75		- &efi.mem_attr_table,
76		-};
	52	+unsigned long __ro_after_init efi_rng_seed = EFI_INVALID_TABLE_ADDR;
	53	+static unsigned long __initdata mem_reserve = EFI_INVALID_TABLE_ADDR;
	54	+static unsigned long __initdata rt_prop = EFI_INVALID_TABLE_ADDR;
77	55
78	56	struct mm_struct efi_mm = {
79	57	.mm_rb = RB_ROOT,
80	58	.mm_users = ATOMIC_INIT(2),
81	59	.mm_count = ATOMIC_INIT(1),
82		- .mmap_sem = __RWSEM_INITIALIZER(efi_mm.mmap_sem),
	60	+ .write_protect_seq = SEQCNT_ZERO(efi_mm.write_protect_seq),
	61	+ MMAP_LOCK_INITIALIZER(efi_mm)
83	62	.page_table_lock = __SPIN_LOCK_UNLOCKED(efi_mm.page_table_lock),
84	63	.mmlist = LIST_HEAD_INIT(efi_mm.mmlist),
85	64	.cpu_bitmap = { [BITS_TO_LONGS(NR_CPUS)] = 0},
..	..	@@ -87,7 +66,7 @@
87	66
88	67	struct workqueue_struct *efi_rts_wq;
89	68
90		-static bool disable_runtime = IS_ENABLED(CONFIG_PREEMPT_RT_BASE);
	69	+static bool disable_runtime;
91	70	static int __init setup_noefi(char *arg)
92	71	{
93	72	disable_runtime = true;
..	..	@@ -98,6 +77,11 @@
98	77	bool efi_runtime_disabled(void)
99	78	{
100	79	return disable_runtime;
	80	+}
	81	+
	82	+bool __pure __efi_soft_reserve_enabled(void)
	83	+{
	84	+ return !efi_enabled(EFI_MEM_NO_SOFT_RESERVE);
101	85	}
102	86
103	87	static int __init parse_efi_cmdline(char *str)
..	..	@@ -113,8 +97,8 @@
113	97	if (parse_option_str(str, "noruntime"))
114	98	disable_runtime = true;
115	99
116		- if (parse_option_str(str, "runtime"))
117		- disable_runtime = false;
	100	+ if (parse_option_str(str, "nosoftreserve"))
	101	+ set_bit(EFI_MEM_NO_SOFT_RESERVE, &efi.flags);
118	102
119	103	return 0;
120	104	}
..	..	@@ -136,8 +120,6 @@
136	120	if (!kobj \|\| !buf)
137	121	return -EINVAL;
138	122
139		- if (efi.mps != EFI_INVALID_TABLE_ADDR)
140		- str += sprintf(str, "MPS=0x%lx\n", efi.mps);
141	123	if (efi.acpi20 != EFI_INVALID_TABLE_ADDR)
142	124	str += sprintf(str, "ACPI20=0x%lx\n", efi.acpi20);
143	125	if (efi.acpi != EFI_INVALID_TABLE_ADDR)
..	..	@@ -151,30 +133,14 @@
151	133	str += sprintf(str, "SMBIOS3=0x%lx\n", efi.smbios3);
152	134	if (efi.smbios != EFI_INVALID_TABLE_ADDR)
153	135	str += sprintf(str, "SMBIOS=0x%lx\n", efi.smbios);
154		- if (efi.hcdp != EFI_INVALID_TABLE_ADDR)
155		- str += sprintf(str, "HCDP=0x%lx\n", efi.hcdp);
156		- if (efi.boot_info != EFI_INVALID_TABLE_ADDR)
157		- str += sprintf(str, "BOOTINFO=0x%lx\n", efi.boot_info);
158		- if (efi.uga != EFI_INVALID_TABLE_ADDR)
159		- str += sprintf(str, "UGA=0x%lx\n", efi.uga);
	136	+
	137	+ if (IS_ENABLED(CONFIG_IA64) \|\| IS_ENABLED(CONFIG_X86))
	138	+ str = efi_systab_show_arch(str);
160	139
161	140	return str - buf;
162	141	}
163	142
164	143	static struct kobj_attribute efi_attr_systab = __ATTR_RO_MODE(systab, 0400);
165		-
166		-#define EFI_FIELD(var) efi.var
167		-
168		-#define EFI_ATTR_SHOW(name) \
169		-static ssize_t name##_show(struct kobject *kobj, \
170		- struct kobj_attribute attr, char buf) \
171		-{ \
172		- return sprintf(buf, "0x%lx\n", EFI_FIELD(name)); \
173		-}
174		-
175		-EFI_ATTR_SHOW(fw_vendor);
176		-EFI_ATTR_SHOW(runtime);
177		-EFI_ATTR_SHOW(config_table);
178	144
179	145	static ssize_t fw_platform_size_show(struct kobject *kobj,
180	146	struct kobj_attribute attr, char buf)
..	..	@@ -182,36 +148,24 @@
182	148	return sprintf(buf, "%d\n", efi_enabled(EFI_64BIT) ? 64 : 32);
183	149	}
184	150
185		-static struct kobj_attribute efi_attr_fw_vendor = __ATTR_RO(fw_vendor);
186		-static struct kobj_attribute efi_attr_runtime = __ATTR_RO(runtime);
187		-static struct kobj_attribute efi_attr_config_table = __ATTR_RO(config_table);
	151	+extern __weak struct kobj_attribute efi_attr_fw_vendor;
	152	+extern __weak struct kobj_attribute efi_attr_runtime;
	153	+extern __weak struct kobj_attribute efi_attr_config_table;
188	154	static struct kobj_attribute efi_attr_fw_platform_size =
189	155	__ATTR_RO(fw_platform_size);
190	156
191	157	static struct attribute *efi_subsys_attrs[] = {
192	158	&efi_attr_systab.attr,
	159	+ &efi_attr_fw_platform_size.attr,
193	160	&efi_attr_fw_vendor.attr,
194	161	&efi_attr_runtime.attr,
195	162	&efi_attr_config_table.attr,
196		- &efi_attr_fw_platform_size.attr,
197	163	NULL,
198	164	};
199	165
200		-static umode_t efi_attr_is_visible(struct kobject *kobj,
201		- struct attribute *attr, int n)
	166	+umode_t __weak efi_attr_is_visible(struct kobject kobj, struct attribute attr,
	167	+ int n)
202	168	{
203		- if (attr == &efi_attr_fw_vendor.attr) {
204		- if (efi_enabled(EFI_PARAVIRT) \|\|
205		- efi.fw_vendor == EFI_INVALID_TABLE_ADDR)
206		- return 0;
207		- } else if (attr == &efi_attr_runtime.attr) {
208		- if (efi.runtime == EFI_INVALID_TABLE_ADDR)
209		- return 0;
210		- } else if (attr == &efi_attr_config_table.attr) {
211		- if (efi.config_table == EFI_INVALID_TABLE_ADDR)
212		- return 0;
213		- }
214		-
215	169	return attr->mode;
216	170	}
217	171
..	..	@@ -226,11 +180,13 @@
226	180	static int generic_ops_register(void)
227	181	{
228	182	generic_ops.get_variable = efi.get_variable;
229		- generic_ops.set_variable = efi.set_variable;
230		- generic_ops.set_variable_nonblocking = efi.set_variable_nonblocking;
231	183	generic_ops.get_next_variable = efi.get_next_variable;
232	184	generic_ops.query_variable_store = efi_query_variable_store;
233	185
	186	+ if (efi_rt_services_supported(EFI_RT_SUPPORTED_SET_VARIABLE)) {
	187	+ generic_ops.set_variable = efi.set_variable;
	188	+ generic_ops.set_variable_nonblocking = efi.set_variable_nonblocking;
	189	+ }
234	190	return efivars_register(&generic_efivars, &generic_ops, efi_kobj);
235	191	}
236	192
..	..	@@ -244,11 +200,16 @@
244	200	static char efivar_ssdt[EFIVAR_SSDT_NAME_MAX] __initdata;
245	201	static int __init efivar_ssdt_setup(char *str)
246	202	{
	203	+ int ret = security_locked_down(LOCKDOWN_ACPI_TABLES);
	204	+
	205	+ if (ret)
	206	+ return ret;
	207	+
247	208	if (strlen(str) < sizeof(efivar_ssdt))
248	209	memcpy(efivar_ssdt, str, strlen(str));
249	210	else
250	211	pr_warn("efivar_ssdt: name too long: %s\n", str);
251		- return 0;
	212	+ return 1;
252	213	}
253	214	__setup("efivar_ssdt=", efivar_ssdt_setup);
254	215
..	..	@@ -313,7 +274,7 @@
313	274	goto free_data;
314	275	}
315	276
316		- ret = acpi_load_table(data);
	277	+ ret = acpi_load_table(data, NULL);
317	278	if (ret) {
318	279	pr_err("failed to load table: %d\n", ret);
319	280	goto free_data;
..	..	@@ -334,6 +295,59 @@
334	295	static inline int efivar_ssdt_load(void) { return 0; }
335	296	#endif
336	297
	298	+#ifdef CONFIG_DEBUG_FS
	299	+
	300	+#define EFI_DEBUGFS_MAX_BLOBS 32
	301	+
	302	+static struct debugfs_blob_wrapper debugfs_blob[EFI_DEBUGFS_MAX_BLOBS];
	303	+
	304	+static void __init efi_debugfs_init(void)
	305	+{
	306	+ struct dentry *efi_debugfs;
	307	+ efi_memory_desc_t *md;
	308	+ char name[32];
	309	+ int type_count[EFI_BOOT_SERVICES_DATA + 1] = {};
	310	+ int i = 0;
	311	+
	312	+ efi_debugfs = debugfs_create_dir("efi", NULL);
	313	+ if (IS_ERR_OR_NULL(efi_debugfs))
	314	+ return;
	315	+
	316	+ for_each_efi_memory_desc(md) {
	317	+ switch (md->type) {
	318	+ case EFI_BOOT_SERVICES_CODE:
	319	+ snprintf(name, sizeof(name), "boot_services_code%d",
	320	+ type_count[md->type]++);
	321	+ break;
	322	+ case EFI_BOOT_SERVICES_DATA:
	323	+ snprintf(name, sizeof(name), "boot_services_data%d",
	324	+ type_count[md->type]++);
	325	+ break;
	326	+ default:
	327	+ continue;
	328	+ }
	329	+
	330	+ if (i >= EFI_DEBUGFS_MAX_BLOBS) {
	331	+ pr_warn("More then %d EFI boot service segments, only showing first %d in debugfs\n",
	332	+ EFI_DEBUGFS_MAX_BLOBS, EFI_DEBUGFS_MAX_BLOBS);
	333	+ break;
	334	+ }
	335	+
	336	+ debugfs_blob[i].size = md->num_pages << EFI_PAGE_SHIFT;
	337	+ debugfs_blob[i].data = memremap(md->phys_addr,
	338	+ debugfs_blob[i].size,
	339	+ MEMREMAP_WB);
	340	+ if (!debugfs_blob[i].data)
	341	+ continue;
	342	+
	343	+ debugfs_create_blob(name, 0400, efi_debugfs, &debugfs_blob[i]);
	344	+ i++;
	345	+ }
	346	+}
	347	+#else
	348	+static inline void efi_debugfs_init(void) {}
	349	+#endif
	350	+
337	351	/*
338	352	* We register the efi subsystem with the firmware subsystem and the
339	353	* efivars subsystem with the efi subsystem, if the system was booted with
..	..	@@ -343,20 +357,29 @@
343	357	{
344	358	int error;
345	359
	360	+ if (!efi_enabled(EFI_RUNTIME_SERVICES))
	361	+ efi.runtime_supported_mask = 0;
	362	+
346	363	if (!efi_enabled(EFI_BOOT))
347	364	return 0;
348	365
349		- /*
350		- * Since we process only one efi_runtime_service() at a time, an
351		- * ordered workqueue (which creates only one execution context)
352		- * should suffice all our needs.
353		- */
354		- efi_rts_wq = alloc_ordered_workqueue("efi_rts_wq", 0);
355		- if (!efi_rts_wq) {
356		- pr_err("Creating efi_rts_wq failed, EFI runtime services disabled.\n");
357		- clear_bit(EFI_RUNTIME_SERVICES, &efi.flags);
358		- return 0;
	366	+ if (efi.runtime_supported_mask) {
	367	+ /*
	368	+ * Since we process only one efi_runtime_service() at a time, an
	369	+ * ordered workqueue (which creates only one execution context)
	370	+ * should suffice for all our needs.
	371	+ */
	372	+ efi_rts_wq = alloc_ordered_workqueue("efi_rts_wq", 0);
	373	+ if (!efi_rts_wq) {
	374	+ pr_err("Creating efi_rts_wq failed, EFI runtime services disabled.\n");
	375	+ clear_bit(EFI_RUNTIME_SERVICES, &efi.flags);
	376	+ efi.runtime_supported_mask = 0;
	377	+ return 0;
	378	+ }
359	379	}
	380	+
	381	+ if (efi_rt_services_supported(EFI_RT_SUPPORTED_TIME_SERVICES))
	382	+ platform_device_register_simple("rtc-efi", 0, NULL, 0);
360	383
361	384	/* We register the efi directory at /sys/firmware/efi */
362	385	efi_kobj = kobject_create_and_add("efi", firmware_kobj);
..	..	@@ -366,12 +389,14 @@
366	389	return -ENOMEM;
367	390	}
368	391
369		- error = generic_ops_register();
370		- if (error)
371		- goto err_put;
372		-
373		- if (efi_enabled(EFI_RUNTIME_SERVICES))
	392	+ if (efi_rt_services_supported(EFI_RT_SUPPORTED_GET_VARIABLE \|
	393	+ EFI_RT_SUPPORTED_GET_NEXT_VARIABLE_NAME)) {
	394	+ error = generic_ops_register();
	395	+ if (error)
	396	+ goto err_put;
374	397	efivar_ssdt_load();
	398	+ platform_device_register_simple("efivars", 0, NULL, 0);
	399	+ }
375	400
376	401	error = sysfs_create_group(efi_kobj, &efi_subsys_attr_group);
377	402	if (error) {
..	..	@@ -391,12 +416,17 @@
391	416	goto err_remove_group;
392	417	}
393	418
	419	+ if (efi_enabled(EFI_DBG) && efi_enabled(EFI_PRESERVE_BS_REGIONS))
	420	+ efi_debugfs_init();
	421	+
394	422	return 0;
395	423
396	424	err_remove_group:
397	425	sysfs_remove_group(efi_kobj, &efi_subsys_attr_group);
398	426	err_unregister:
399		- generic_ops_unregister();
	427	+ if (efi_rt_services_supported(EFI_RT_SUPPORTED_GET_VARIABLE \|
	428	+ EFI_RT_SUPPORTED_GET_NEXT_VARIABLE_NAME))
	429	+ generic_ops_unregister();
400	430	err_put:
401	431	kobject_put(efi_kobj);
402	432	destroy_workqueue(efi_rts_wq);
..	..	@@ -478,98 +508,99 @@
478	508	efi_arch_mem_reserve(addr, size);
479	509	}
480	510
481		-static __initdata efi_config_table_type_t common_tables[] = {
482		- {ACPI_20_TABLE_GUID, "ACPI 2.0", &efi.acpi20},
483		- {ACPI_TABLE_GUID, "ACPI", &efi.acpi},
484		- {HCDP_TABLE_GUID, "HCDP", &efi.hcdp},
485		- {MPS_TABLE_GUID, "MPS", &efi.mps},
486		- {SAL_SYSTEM_TABLE_GUID, "SALsystab", &efi.sal_systab},
487		- {SMBIOS_TABLE_GUID, "SMBIOS", &efi.smbios},
488		- {SMBIOS3_TABLE_GUID, "SMBIOS 3.0", &efi.smbios3},
489		- {UGA_IO_PROTOCOL_GUID, "UGA", &efi.uga},
490		- {EFI_SYSTEM_RESOURCE_TABLE_GUID, "ESRT", &efi.esrt},
491		- {EFI_PROPERTIES_TABLE_GUID, "PROP", &efi.properties_table},
492		- {EFI_MEMORY_ATTRIBUTES_TABLE_GUID, "MEMATTR", &efi.mem_attr_table},
493		- {LINUX_EFI_RANDOM_SEED_TABLE_GUID, "RNG", &efi.rng_seed},
494		- {LINUX_EFI_TPM_EVENT_LOG_GUID, "TPMEventLog", &efi.tpm_log},
495		- {NULL_GUID, NULL, NULL},
	511	+static const efi_config_table_type_t common_tables[] __initconst = {
	512	+ {ACPI_20_TABLE_GUID, &efi.acpi20, "ACPI 2.0" },
	513	+ {ACPI_TABLE_GUID, &efi.acpi, "ACPI" },
	514	+ {SMBIOS_TABLE_GUID, &efi.smbios, "SMBIOS" },
	515	+ {SMBIOS3_TABLE_GUID, &efi.smbios3, "SMBIOS 3.0" },
	516	+ {EFI_SYSTEM_RESOURCE_TABLE_GUID, &efi.esrt, "ESRT" },
	517	+ {EFI_MEMORY_ATTRIBUTES_TABLE_GUID, &efi_mem_attr_table, "MEMATTR" },
	518	+ {LINUX_EFI_RANDOM_SEED_TABLE_GUID, &efi_rng_seed, "RNG" },
	519	+ {LINUX_EFI_TPM_EVENT_LOG_GUID, &efi.tpm_log, "TPMEventLog" },
	520	+ {LINUX_EFI_TPM_FINAL_LOG_GUID, &efi.tpm_final_log, "TPMFinalLog" },
	521	+ {LINUX_EFI_MEMRESERVE_TABLE_GUID, &mem_reserve, "MEMRESERVE" },
	522	+ {EFI_RT_PROPERTIES_TABLE_GUID, &rt_prop, "RTPROP" },
	523	+#ifdef CONFIG_EFI_RCI2_TABLE
	524	+ {DELLEMC_EFI_RCI2_TABLE_GUID, &rci2_table_phys },
	525	+#endif
	526	+#ifdef CONFIG_LOAD_UEFI_KEYS
	527	+ {LINUX_EFI_MOK_VARIABLE_TABLE_GUID, &efi.mokvar_table, "MOKvar" },
	528	+#endif
	529	+ {},
496	530	};
497	531
498		-static __init int match_config_table(efi_guid_t *guid,
	532	+static __init int match_config_table(const efi_guid_t *guid,
499	533	unsigned long table,
500		- efi_config_table_type_t *table_types)
	534	+ const efi_config_table_type_t *table_types)
501	535	{
502	536	int i;
503	537
504		- if (table_types) {
505		- for (i = 0; efi_guidcmp(table_types[i].guid, NULL_GUID); i++) {
506		- if (!efi_guidcmp(*guid, table_types[i].guid)) {
507		- *(table_types[i].ptr) = table;
508		- if (table_types[i].name)
509		- pr_cont(" %s=0x%lx ",
510		- table_types[i].name, table);
511		- return 1;
512		- }
	538	+ for (i = 0; efi_guidcmp(table_types[i].guid, NULL_GUID); i++) {
	539	+ if (!efi_guidcmp(*guid, table_types[i].guid)) {
	540	+ *(table_types[i].ptr) = table;
	541	+ if (table_types[i].name[0])
	542	+ pr_cont("%s=0x%lx ",
	543	+ table_types[i].name, table);
	544	+ return 1;
513	545	}
514	546	}
515	547
516	548	return 0;
517	549	}
518	550
519		-int __init efi_config_parse_tables(void *config_tables, int count, int sz,
520		- efi_config_table_type_t *arch_tables)
	551	+int __init efi_config_parse_tables(const efi_config_table_t *config_tables,
	552	+ int count,
	553	+ const efi_config_table_type_t *arch_tables)
521	554	{
522		- void *tablep;
	555	+ const efi_config_table_64_t tbl64 = (void )config_tables;
	556	+ const efi_config_table_32_t tbl32 = (void )config_tables;
	557	+ const efi_guid_t *guid;
	558	+ unsigned long table;
523	559	int i;
524	560
525		- tablep = config_tables;
526	561	pr_info("");
527	562	for (i = 0; i < count; i++) {
528		- efi_guid_t guid;
529		- unsigned long table;
	563	+ if (!IS_ENABLED(CONFIG_X86)) {
	564	+ guid = &config_tables[i].guid;
	565	+ table = (unsigned long)config_tables[i].table;
	566	+ } else if (efi_enabled(EFI_64BIT)) {
	567	+ guid = &tbl64[i].guid;
	568	+ table = tbl64[i].table;
530	569
531		- if (efi_enabled(EFI_64BIT)) {
532		- u64 table64;
533		- guid = ((efi_config_table_64_t *)tablep)->guid;
534		- table64 = ((efi_config_table_64_t *)tablep)->table;
535		- table = table64;
536		-#ifndef CONFIG_64BIT
537		- if (table64 >> 32) {
	570	+ if (IS_ENABLED(CONFIG_X86_32) &&
	571	+ tbl64[i].table > U32_MAX) {
538	572	pr_cont("\n");
539	573	pr_err("Table located above 4GB, disabling EFI.\n");
540	574	return -EINVAL;
541	575	}
542		-#endif
543	576	} else {
544		- guid = ((efi_config_table_32_t *)tablep)->guid;
545		- table = ((efi_config_table_32_t *)tablep)->table;
	577	+ guid = &tbl32[i].guid;
	578	+ table = tbl32[i].table;
546	579	}
547	580
548		- if (!match_config_table(&guid, table, common_tables))
549		- match_config_table(&guid, table, arch_tables);
550		-
551		- tablep += sz;
	581	+ if (!match_config_table(guid, table, common_tables) && arch_tables)
	582	+ match_config_table(guid, table, arch_tables);
552	583	}
553	584	pr_cont("\n");
554	585	set_bit(EFI_CONFIG_TABLES, &efi.flags);
555	586
556		- if (efi.rng_seed != EFI_INVALID_TABLE_ADDR) {
	587	+ if (efi_rng_seed != EFI_INVALID_TABLE_ADDR) {
557	588	struct linux_efi_random_seed *seed;
558	589	u32 size = 0;
559	590
560		- seed = early_memremap(efi.rng_seed, sizeof(*seed));
	591	+ seed = early_memremap(efi_rng_seed, sizeof(*seed));
561	592	if (seed != NULL) {
562		- size = seed->size;
	593	+ size = min(seed->size, EFI_RANDOM_SEED_SIZE);
563	594	early_memunmap(seed, sizeof(*seed));
564	595	} else {
565	596	pr_err("Could not map UEFI random seed!\n");
566	597	}
567	598	if (size > 0) {
568		- seed = early_memremap(efi.rng_seed,
	599	+ seed = early_memremap(efi_rng_seed,
569	600	sizeof(*seed) + size);
570	601	if (seed != NULL) {
571	602	pr_notice("seeding entropy pool\n");
572		- add_device_randomness(seed->bits, seed->size);
	603	+ add_bootloader_randomness(seed->bits, size);
573	604	early_memunmap(seed, sizeof(*seed) + size);
574	605	} else {
575	606	pr_err("Could not map UEFI random seed!\n");
..	..	@@ -582,202 +613,122 @@
582	613
583	614	efi_tpm_eventlog_init();
584	615
585		- /* Parse the EFI Properties table if it exists */
586		- if (efi.properties_table != EFI_INVALID_TABLE_ADDR) {
587		- efi_properties_table_t *tbl;
	616	+ if (mem_reserve != EFI_INVALID_TABLE_ADDR) {
	617	+ unsigned long prsv = mem_reserve;
588	618
589		- tbl = early_memremap(efi.properties_table, sizeof(*tbl));
590		- if (tbl == NULL) {
591		- pr_err("Could not map Properties table!\n");
592		- return -ENOMEM;
	619	+ while (prsv) {
	620	+ struct linux_efi_memreserve *rsv;
	621	+ u8 *p;
	622	+
	623	+ /*
	624	+ * Just map a full page: that is what we will get
	625	+ * anyway, and it permits us to map the entire entry
	626	+ * before knowing its size.
	627	+ */
	628	+ p = early_memremap(ALIGN_DOWN(prsv, PAGE_SIZE),
	629	+ PAGE_SIZE);
	630	+ if (p == NULL) {
	631	+ pr_err("Could not map UEFI memreserve entry!\n");
	632	+ return -ENOMEM;
	633	+ }
	634	+
	635	+ rsv = (void *)(p + prsv % PAGE_SIZE);
	636	+
	637	+ /* reserve the entry itself */
	638	+ memblock_reserve(prsv,
	639	+ struct_size(rsv, entry, rsv->size));
	640	+
	641	+ for (i = 0; i < atomic_read(&rsv->count); i++) {
	642	+ memblock_reserve(rsv->entry[i].base,
	643	+ rsv->entry[i].size);
	644	+ }
	645	+
	646	+ prsv = rsv->next;
	647	+ early_memunmap(p, PAGE_SIZE);
593	648	}
	649	+ }
594	650
595		- if (tbl->memory_protection_attribute &
596		- EFI_PROPERTIES_RUNTIME_MEMORY_PROTECTION_NON_EXECUTABLE_PE_DATA)
597		- set_bit(EFI_NX_PE_DATA, &efi.flags);
	651	+ if (rt_prop != EFI_INVALID_TABLE_ADDR) {
	652	+ efi_rt_properties_table_t *tbl;
598	653
599		- early_memunmap(tbl, sizeof(*tbl));
	654	+ tbl = early_memremap(rt_prop, sizeof(*tbl));
	655	+ if (tbl) {
	656	+ efi.runtime_supported_mask &= tbl->runtime_services_supported;
	657	+ early_memunmap(tbl, sizeof(*tbl));
	658	+ }
600	659	}
601	660
602	661	return 0;
603	662	}
604	663
605		-int __init efi_config_init(efi_config_table_type_t *arch_tables)
	664	+int __init efi_systab_check_header(const efi_table_hdr_t *systab_hdr,
	665	+ int min_major_version)
606	666	{
607		- void *config_tables;
608		- int sz, ret;
609		-
610		- if (efi_enabled(EFI_64BIT))
611		- sz = sizeof(efi_config_table_64_t);
612		- else
613		- sz = sizeof(efi_config_table_32_t);
614		-
615		- /*
616		- * Let's see what config tables the firmware passed to us.
617		- */
618		- config_tables = early_memremap(efi.systab->tables,
619		- efi.systab->nr_tables * sz);
620		- if (config_tables == NULL) {
621		- pr_err("Could not map Configuration table!\n");
622		- return -ENOMEM;
	667	+ if (systab_hdr->signature != EFI_SYSTEM_TABLE_SIGNATURE) {
	668	+ pr_err("System table signature incorrect!\n");
	669	+ return -EINVAL;
623	670	}
624	671
625		- ret = efi_config_parse_tables(config_tables, efi.systab->nr_tables, sz,
626		- arch_tables);
	672	+ if ((systab_hdr->revision >> 16) < min_major_version)
	673	+ pr_err("Warning: System table version %d.%02d, expected %d.00 or greater!\n",
	674	+ systab_hdr->revision >> 16,
	675	+ systab_hdr->revision & 0xffff,
	676	+ min_major_version);
627	677
628		- early_memunmap(config_tables, efi.systab->nr_tables * sz);
	678	+ return 0;
	679	+}
	680	+
	681	+#ifndef CONFIG_IA64
	682	+static const efi_char16_t *__init map_fw_vendor(unsigned long fw_vendor,
	683	+ size_t size)
	684	+{
	685	+ const efi_char16_t *ret;
	686	+
	687	+ ret = early_memremap_ro(fw_vendor, size);
	688	+ if (!ret)
	689	+ pr_err("Could not map the firmware vendor!\n");
629	690	return ret;
630	691	}
631	692
632		-#ifdef CONFIG_EFI_VARS_MODULE
633		-static int __init efi_load_efivars(void)
	693	+static void __init unmap_fw_vendor(const void *fw_vendor, size_t size)
634	694	{
635		- struct platform_device *pdev;
636		-
637		- if (!efi_enabled(EFI_RUNTIME_SERVICES))
638		- return 0;
639		-
640		- pdev = platform_device_register_simple("efivars", 0, NULL, 0);
641		- return PTR_ERR_OR_ZERO(pdev);
	695	+ early_memunmap((void *)fw_vendor, size);
642	696	}
643		-device_initcall(efi_load_efivars);
	697	+#else
	698	+#define map_fw_vendor(p, s) __va(p)
	699	+#define unmap_fw_vendor(v, s)
644	700	#endif
645	701
646		-#ifdef CONFIG_EFI_PARAMS_FROM_FDT
	702	+void __init efi_systab_report_header(const efi_table_hdr_t *systab_hdr,
	703	+ unsigned long fw_vendor)
	704	+{
	705	+ char vendor[100] = "unknown";
	706	+ const efi_char16_t *c16;
	707	+ size_t i;
647	708
648		-#define UEFI_PARAM(name, prop, field) \
649		- { \
650		- { name }, \
651		- { prop }, \
652		- offsetof(struct efi_fdt_params, field), \
653		- FIELD_SIZEOF(struct efi_fdt_params, field) \
	709	+ c16 = map_fw_vendor(fw_vendor, sizeof(vendor) * sizeof(efi_char16_t));
	710	+ if (c16) {
	711	+ for (i = 0; i < sizeof(vendor) - 1 && c16[i]; ++i)
	712	+ vendor[i] = c16[i];
	713	+ vendor[i] = '\0';
	714	+
	715	+ unmap_fw_vendor(c16, sizeof(vendor) * sizeof(efi_char16_t));
654	716	}
655	717
656		-struct params {
657		- const char name[32];
658		- const char propname[32];
659		- int offset;
660		- int size;
661		-};
	718	+ pr_info("EFI v%u.%.02u by %s\n",
	719	+ systab_hdr->revision >> 16,
	720	+ systab_hdr->revision & 0xffff,
	721	+ vendor);
662	722
663		-static __initdata struct params fdt_params[] = {
664		- UEFI_PARAM("System Table", "linux,uefi-system-table", system_table),
665		- UEFI_PARAM("MemMap Address", "linux,uefi-mmap-start", mmap),
666		- UEFI_PARAM("MemMap Size", "linux,uefi-mmap-size", mmap_size),
667		- UEFI_PARAM("MemMap Desc. Size", "linux,uefi-mmap-desc-size", desc_size),
668		- UEFI_PARAM("MemMap Desc. Version", "linux,uefi-mmap-desc-ver", desc_ver)
669		-};
670		-
671		-static __initdata struct params xen_fdt_params[] = {
672		- UEFI_PARAM("System Table", "xen,uefi-system-table", system_table),
673		- UEFI_PARAM("MemMap Address", "xen,uefi-mmap-start", mmap),
674		- UEFI_PARAM("MemMap Size", "xen,uefi-mmap-size", mmap_size),
675		- UEFI_PARAM("MemMap Desc. Size", "xen,uefi-mmap-desc-size", desc_size),
676		- UEFI_PARAM("MemMap Desc. Version", "xen,uefi-mmap-desc-ver", desc_ver)
677		-};
678		-
679		-#define EFI_FDT_PARAMS_SIZE ARRAY_SIZE(fdt_params)
680		-
681		-static __initdata struct {
682		- const char *uname;
683		- const char *subnode;
684		- struct params *params;
685		-} dt_params[] = {
686		- { "hypervisor", "uefi", xen_fdt_params },
687		- { "chosen", NULL, fdt_params },
688		-};
689		-
690		-struct param_info {
691		- int found;
692		- void *params;
693		- const char *missing;
694		-};
695		-
696		-static int __init __find_uefi_params(unsigned long node,
697		- struct param_info *info,
698		- struct params *params)
699		-{
700		- const void *prop;
701		- void *dest;
702		- u64 val;
703		- int i, len;
704		-
705		- for (i = 0; i < EFI_FDT_PARAMS_SIZE; i++) {
706		- prop = of_get_flat_dt_prop(node, params[i].propname, &len);
707		- if (!prop) {
708		- info->missing = params[i].name;
709		- return 0;
710		- }
711		-
712		- dest = info->params + params[i].offset;
713		- info->found++;
714		-
715		- val = of_read_number(prop, len / sizeof(u32));
716		-
717		- if (params[i].size == sizeof(u32))
718		- (u32 )dest = val;
719		- else
720		- (u64 )dest = val;
721		-
722		- if (efi_enabled(EFI_DBG))
723		- pr_info(" %s: 0x%0*llx\n", params[i].name,
724		- params[i].size * 2, val);
	723	+ if (IS_ENABLED(CONFIG_X86_64) &&
	724	+ systab_hdr->revision > EFI_1_10_SYSTEM_TABLE_REVISION &&
	725	+ !strcmp(vendor, "Apple")) {
	726	+ pr_info("Apple Mac detected, using EFI v1.10 runtime services only\n");
	727	+ efi.runtime_version = EFI_1_10_SYSTEM_TABLE_REVISION;
725	728	}
726		-
727		- return 1;
728	729	}
729	730
730		-static int __init fdt_find_uefi_params(unsigned long node, const char *uname,
731		- int depth, void *data)
732		-{
733		- struct param_info *info = data;
734		- int i;
735		-
736		- for (i = 0; i < ARRAY_SIZE(dt_params); i++) {
737		- const char *subnode = dt_params[i].subnode;
738		-
739		- if (depth != 1 \|\| strcmp(uname, dt_params[i].uname) != 0) {
740		- info->missing = dt_params[i].params[0].name;
741		- continue;
742		- }
743		-
744		- if (subnode) {
745		- int err = of_get_flat_dt_subnode_by_name(node, subnode);
746		-
747		- if (err < 0)
748		- return 0;
749		-
750		- node = err;
751		- }
752		-
753		- return __find_uefi_params(node, info, dt_params[i].params);
754		- }
755		-
756		- return 0;
757		-}
758		-
759		-int __init efi_get_fdt_params(struct efi_fdt_params *params)
760		-{
761		- struct param_info info;
762		- int ret;
763		-
764		- pr_info("Getting EFI parameters from FDT:\n");
765		-
766		- info.found = 0;
767		- info.params = params;
768		-
769		- ret = of_scan_flat_dt(fdt_find_uefi_params, &info);
770		- if (!info.found)
771		- pr_info("UEFI not found.\n");
772		- else if (!ret)
773		- pr_err("Can't find '%s' in device tree!\n",
774		- info.missing);
775		-
776		- return ret;
777		-}
778		-#endif /* CONFIG_EFI_PARAMS_FROM_FDT */
779		-
780		-static __initdata char memory_type_name[][20] = {
	731	+static __initdata char memory_type_name[][13] = {
781	732	"Reserved",
782	733	"Loader Code",
783	734	"Loader Data",
..	..	@@ -785,14 +736,14 @@
785	736	"Boot Data",
786	737	"Runtime Code",
787	738	"Runtime Data",
788		- "Conventional Memory",
789		- "Unusable Memory",
790		- "ACPI Reclaim Memory",
791		- "ACPI Memory NVS",
792		- "Memory Mapped I/O",
793		- "MMIO Port Space",
	739	+ "Conventional",
	740	+ "Unusable",
	741	+ "ACPI Reclaim",
	742	+ "ACPI Mem NVS",
	743	+ "MMIO",
	744	+ "MMIO Port",
794	745	"PAL Code",
795		- "Persistent Memory",
	746	+ "Persistent",
796	747	};
797	748
798	749	char * __init efi_md_typeattr_format(char *buf, size_t size,
..	..	@@ -819,25 +770,27 @@
819	770	if (attr & ~(EFI_MEMORY_UC \| EFI_MEMORY_WC \| EFI_MEMORY_WT \|
820	771	EFI_MEMORY_WB \| EFI_MEMORY_UCE \| EFI_MEMORY_RO \|
821	772	EFI_MEMORY_WP \| EFI_MEMORY_RP \| EFI_MEMORY_XP \|
822		- EFI_MEMORY_NV \|
	773	+ EFI_MEMORY_NV \| EFI_MEMORY_SP \| EFI_MEMORY_CPU_CRYPTO \|
823	774	EFI_MEMORY_RUNTIME \| EFI_MEMORY_MORE_RELIABLE))
824	775	snprintf(pos, size, "\|attr=0x%016llx]",
825	776	(unsigned long long)attr);
826	777	else
827	778	snprintf(pos, size,
828		- "\|%3s\|%2s\|%2s\|%2s\|%2s\|%2s\|%2s\|%3s\|%2s\|%2s\|%2s\|%2s]",
829		- attr & EFI_MEMORY_RUNTIME ? "RUN" : "",
830		- attr & EFI_MEMORY_MORE_RELIABLE ? "MR" : "",
831		- attr & EFI_MEMORY_NV ? "NV" : "",
832		- attr & EFI_MEMORY_XP ? "XP" : "",
833		- attr & EFI_MEMORY_RP ? "RP" : "",
834		- attr & EFI_MEMORY_WP ? "WP" : "",
835		- attr & EFI_MEMORY_RO ? "RO" : "",
836		- attr & EFI_MEMORY_UCE ? "UCE" : "",
837		- attr & EFI_MEMORY_WB ? "WB" : "",
838		- attr & EFI_MEMORY_WT ? "WT" : "",
839		- attr & EFI_MEMORY_WC ? "WC" : "",
840		- attr & EFI_MEMORY_UC ? "UC" : "");
	779	+ "\|%3s\|%2s\|%2s\|%2s\|%2s\|%2s\|%2s\|%2s\|%2s\|%3s\|%2s\|%2s\|%2s\|%2s]",
	780	+ attr & EFI_MEMORY_RUNTIME ? "RUN" : "",
	781	+ attr & EFI_MEMORY_MORE_RELIABLE ? "MR" : "",
	782	+ attr & EFI_MEMORY_CPU_CRYPTO ? "CC" : "",
	783	+ attr & EFI_MEMORY_SP ? "SP" : "",
	784	+ attr & EFI_MEMORY_NV ? "NV" : "",
	785	+ attr & EFI_MEMORY_XP ? "XP" : "",
	786	+ attr & EFI_MEMORY_RP ? "RP" : "",
	787	+ attr & EFI_MEMORY_WP ? "WP" : "",
	788	+ attr & EFI_MEMORY_RO ? "RO" : "",
	789	+ attr & EFI_MEMORY_UCE ? "UCE" : "",
	790	+ attr & EFI_MEMORY_WB ? "WB" : "",
	791	+ attr & EFI_MEMORY_WT ? "WT" : "",
	792	+ attr & EFI_MEMORY_WC ? "WC" : "",
	793	+ attr & EFI_MEMORY_UC ? "UC" : "");
841	794	return buf;
842	795	}
843	796
..	..	@@ -876,7 +829,7 @@
876	829	*
877	830	* Search in the EFI memory map for the region covering @phys_addr.
878	831	* Returns the EFI memory type if the region was found in the memory
879		- * map, EFI_RESERVED_TYPE (zero) otherwise.
	832	+ * map, -EINVAL otherwise.
880	833	*/
881	834	int efi_mem_type(unsigned long phys_addr)
882	835	{
..	..	@@ -931,19 +884,120 @@
931	884	return err;
932	885	}
933	886
934		-bool efi_is_table_address(unsigned long phys_addr)
	887	+static DEFINE_SPINLOCK(efi_mem_reserve_persistent_lock);
	888	+static struct linux_efi_memreserve *efi_memreserve_root __ro_after_init;
	889	+
	890	+static int __init efi_memreserve_map_root(void)
935	891	{
936		- unsigned int i;
	892	+ if (mem_reserve == EFI_INVALID_TABLE_ADDR)
	893	+ return -ENODEV;
937	894
938		- if (phys_addr == EFI_INVALID_TABLE_ADDR)
939		- return false;
940		-
941		- for (i = 0; i < ARRAY_SIZE(efi_tables); i++)
942		- if (*(efi_tables[i]) == phys_addr)
943		- return true;
944		-
945		- return false;
	895	+ efi_memreserve_root = memremap(mem_reserve,
	896	+ sizeof(*efi_memreserve_root),
	897	+ MEMREMAP_WB);
	898	+ if (WARN_ON_ONCE(!efi_memreserve_root))
	899	+ return -ENOMEM;
	900	+ return 0;
946	901	}
	902	+
	903	+static int efi_mem_reserve_iomem(phys_addr_t addr, u64 size)
	904	+{
	905	+ struct resource res, parent;
	906	+ int ret;
	907	+
	908	+ res = kzalloc(sizeof(struct resource), GFP_ATOMIC);
	909	+ if (!res)
	910	+ return -ENOMEM;
	911	+
	912	+ res->name = "reserved";
	913	+ res->flags = IORESOURCE_MEM;
	914	+ res->start = addr;
	915	+ res->end = addr + size - 1;
	916	+
	917	+ /* we expect a conflict with a 'System RAM' region */
	918	+ parent = request_resource_conflict(&iomem_resource, res);
	919	+ ret = parent ? request_resource(parent, res) : 0;
	920	+
	921	+ /*
	922	+ * Given that efi_mem_reserve_iomem() can be called at any
	923	+ * time, only call memblock_reserve() if the architecture
	924	+ * keeps the infrastructure around.
	925	+ */
	926	+ if (IS_ENABLED(CONFIG_ARCH_KEEP_MEMBLOCK) && !ret)
	927	+ memblock_reserve(addr, size);
	928	+
	929	+ return ret;
	930	+}
	931	+
	932	+int __ref efi_mem_reserve_persistent(phys_addr_t addr, u64 size)
	933	+{
	934	+ struct linux_efi_memreserve *rsv;
	935	+ unsigned long prsv;
	936	+ int rc, index;
	937	+
	938	+ if (efi_memreserve_root == (void *)ULONG_MAX)
	939	+ return -ENODEV;
	940	+
	941	+ if (!efi_memreserve_root) {
	942	+ rc = efi_memreserve_map_root();
	943	+ if (rc)
	944	+ return rc;
	945	+ }
	946	+
	947	+ /* first try to find a slot in an existing linked list entry */
	948	+ for (prsv = efi_memreserve_root->next; prsv; ) {
	949	+ rsv = memremap(prsv, sizeof(*rsv), MEMREMAP_WB);
	950	+ index = atomic_fetch_add_unless(&rsv->count, 1, rsv->size);
	951	+ if (index < rsv->size) {
	952	+ rsv->entry[index].base = addr;
	953	+ rsv->entry[index].size = size;
	954	+
	955	+ memunmap(rsv);
	956	+ return efi_mem_reserve_iomem(addr, size);
	957	+ }
	958	+ prsv = rsv->next;
	959	+ memunmap(rsv);
	960	+ }
	961	+
	962	+ /* no slot found - allocate a new linked list entry */
	963	+ rsv = (struct linux_efi_memreserve *)__get_free_page(GFP_ATOMIC);
	964	+ if (!rsv)
	965	+ return -ENOMEM;
	966	+
	967	+ rc = efi_mem_reserve_iomem(__pa(rsv), SZ_4K);
	968	+ if (rc) {
	969	+ free_page((unsigned long)rsv);
	970	+ return rc;
	971	+ }
	972	+
	973	+ /*
	974	+ * The memremap() call above assumes that a linux_efi_memreserve entry
	975	+ * never crosses a page boundary, so let's ensure that this remains true
	976	+ * even when kexec'ing a 4k pages kernel from a >4k pages kernel, by
	977	+ * using SZ_4K explicitly in the size calculation below.
	978	+ */
	979	+ rsv->size = EFI_MEMRESERVE_COUNT(SZ_4K);
	980	+ atomic_set(&rsv->count, 1);
	981	+ rsv->entry[0].base = addr;
	982	+ rsv->entry[0].size = size;
	983	+
	984	+ spin_lock(&efi_mem_reserve_persistent_lock);
	985	+ rsv->next = efi_memreserve_root->next;
	986	+ efi_memreserve_root->next = __pa(rsv);
	987	+ spin_unlock(&efi_mem_reserve_persistent_lock);
	988	+
	989	+ return efi_mem_reserve_iomem(addr, size);
	990	+}
	991	+
	992	+static int __init efi_memreserve_root_init(void)
	993	+{
	994	+ if (efi_memreserve_root)
	995	+ return 0;
	996	+ if (efi_memreserve_map_root())
	997	+ efi_memreserve_root = (void *)ULONG_MAX;
	998	+ return 0;
	999	+}
	1000	+early_initcall(efi_memreserve_root_init);
947	1001
948	1002	#ifdef CONFIG_KEXEC
949	1003	static int update_efi_random_seed(struct notifier_block *nb,
..	..	@@ -955,7 +1009,7 @@
955	1009	if (!kexec_in_progress)
956	1010	return NOTIFY_DONE;
957	1011
958		- seed = memremap(efi.rng_seed, sizeof(*seed), MEMREMAP_WB);
	1012	+ seed = memremap(efi_rng_seed, sizeof(*seed), MEMREMAP_WB);
959	1013	if (seed != NULL) {
960	1014	size = min(seed->size, EFI_RANDOM_SEED_SIZE);
961	1015	memunmap(seed);
..	..	@@ -963,7 +1017,7 @@
963	1017	pr_err("Could not map UEFI random seed!\n");
964	1018	}
965	1019	if (size > 0) {
966		- seed = memremap(efi.rng_seed, sizeof(*seed) + size,
	1020	+ seed = memremap(efi_rng_seed, sizeof(*seed) + size,
967	1021	MEMREMAP_WB);
968	1022	if (seed != NULL) {
969	1023	seed->size = size;
..	..	@@ -980,9 +1034,9 @@
980	1034	.notifier_call = update_efi_random_seed,
981	1035	};
982	1036
983		-static int register_update_efi_random_seed(void)
	1037	+static int __init register_update_efi_random_seed(void)
984	1038	{
985		- if (efi.rng_seed == EFI_INVALID_TABLE_ADDR)
	1039	+ if (efi_rng_seed == EFI_INVALID_TABLE_ADDR)
986	1040	return 0;
987	1041	return register_reboot_notifier(&efi_random_seed_nb);
988	1042	}