~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 = IS_ENABLED(CONFIG_PREEMPT_RT);
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)
..	..	@@ -115,6 +99,9 @@
115	99
116	100	if (parse_option_str(str, "runtime"))
117	101	disable_runtime = false;
	102	+
	103	+ if (parse_option_str(str, "nosoftreserve"))
	104	+ set_bit(EFI_MEM_NO_SOFT_RESERVE, &efi.flags);
118	105
119	106	return 0;
120	107	}
..	..	@@ -136,8 +123,6 @@
136	123	if (!kobj \|\| !buf)
137	124	return -EINVAL;
138	125
139		- if (efi.mps != EFI_INVALID_TABLE_ADDR)
140		- str += sprintf(str, "MPS=0x%lx\n", efi.mps);
141	126	if (efi.acpi20 != EFI_INVALID_TABLE_ADDR)
142	127	str += sprintf(str, "ACPI20=0x%lx\n", efi.acpi20);
143	128	if (efi.acpi != EFI_INVALID_TABLE_ADDR)
..	..	@@ -151,30 +136,14 @@
151	136	str += sprintf(str, "SMBIOS3=0x%lx\n", efi.smbios3);
152	137	if (efi.smbios != EFI_INVALID_TABLE_ADDR)
153	138	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);
	139	+
	140	+ if (IS_ENABLED(CONFIG_IA64) \|\| IS_ENABLED(CONFIG_X86))
	141	+ str = efi_systab_show_arch(str);
160	142
161	143	return str - buf;
162	144	}
163	145
164	146	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	147
179	148	static ssize_t fw_platform_size_show(struct kobject *kobj,
180	149	struct kobj_attribute attr, char buf)
..	..	@@ -182,36 +151,24 @@
182	151	return sprintf(buf, "%d\n", efi_enabled(EFI_64BIT) ? 64 : 32);
183	152	}
184	153
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);
	154	+extern __weak struct kobj_attribute efi_attr_fw_vendor;
	155	+extern __weak struct kobj_attribute efi_attr_runtime;
	156	+extern __weak struct kobj_attribute efi_attr_config_table;
188	157	static struct kobj_attribute efi_attr_fw_platform_size =
189	158	__ATTR_RO(fw_platform_size);
190	159
191	160	static struct attribute *efi_subsys_attrs[] = {
192	161	&efi_attr_systab.attr,
	162	+ &efi_attr_fw_platform_size.attr,
193	163	&efi_attr_fw_vendor.attr,
194	164	&efi_attr_runtime.attr,
195	165	&efi_attr_config_table.attr,
196		- &efi_attr_fw_platform_size.attr,
197	166	NULL,
198	167	};
199	168
200		-static umode_t efi_attr_is_visible(struct kobject *kobj,
201		- struct attribute *attr, int n)
	169	+umode_t __weak efi_attr_is_visible(struct kobject kobj, struct attribute attr,
	170	+ int n)
202	171	{
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	172	return attr->mode;
216	173	}
217	174
..	..	@@ -226,11 +183,13 @@
226	183	static int generic_ops_register(void)
227	184	{
228	185	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	186	generic_ops.get_next_variable = efi.get_next_variable;
232	187	generic_ops.query_variable_store = efi_query_variable_store;
233	188
	189	+ if (efi_rt_services_supported(EFI_RT_SUPPORTED_SET_VARIABLE)) {
	190	+ generic_ops.set_variable = efi.set_variable;
	191	+ generic_ops.set_variable_nonblocking = efi.set_variable_nonblocking;
	192	+ }
234	193	return efivars_register(&generic_efivars, &generic_ops, efi_kobj);
235	194	}
236	195
..	..	@@ -244,11 +203,16 @@
244	203	static char efivar_ssdt[EFIVAR_SSDT_NAME_MAX] __initdata;
245	204	static int __init efivar_ssdt_setup(char *str)
246	205	{
	206	+ int ret = security_locked_down(LOCKDOWN_ACPI_TABLES);
	207	+
	208	+ if (ret)
	209	+ return ret;
	210	+
247	211	if (strlen(str) < sizeof(efivar_ssdt))
248	212	memcpy(efivar_ssdt, str, strlen(str));
249	213	else
250	214	pr_warn("efivar_ssdt: name too long: %s\n", str);
251		- return 0;
	215	+ return 1;
252	216	}
253	217	__setup("efivar_ssdt=", efivar_ssdt_setup);
254	218
..	..	@@ -313,7 +277,7 @@
313	277	goto free_data;
314	278	}
315	279
316		- ret = acpi_load_table(data);
	280	+ ret = acpi_load_table(data, NULL);
317	281	if (ret) {
318	282	pr_err("failed to load table: %d\n", ret);
319	283	goto free_data;
..	..	@@ -334,6 +298,59 @@
334	298	static inline int efivar_ssdt_load(void) { return 0; }
335	299	#endif
336	300
	301	+#ifdef CONFIG_DEBUG_FS
	302	+
	303	+#define EFI_DEBUGFS_MAX_BLOBS 32
	304	+
	305	+static struct debugfs_blob_wrapper debugfs_blob[EFI_DEBUGFS_MAX_BLOBS];
	306	+
	307	+static void __init efi_debugfs_init(void)
	308	+{
	309	+ struct dentry *efi_debugfs;
	310	+ efi_memory_desc_t *md;
	311	+ char name[32];
	312	+ int type_count[EFI_BOOT_SERVICES_DATA + 1] = {};
	313	+ int i = 0;
	314	+
	315	+ efi_debugfs = debugfs_create_dir("efi", NULL);
	316	+ if (IS_ERR_OR_NULL(efi_debugfs))
	317	+ return;
	318	+
	319	+ for_each_efi_memory_desc(md) {
	320	+ switch (md->type) {
	321	+ case EFI_BOOT_SERVICES_CODE:
	322	+ snprintf(name, sizeof(name), "boot_services_code%d",
	323	+ type_count[md->type]++);
	324	+ break;
	325	+ case EFI_BOOT_SERVICES_DATA:
	326	+ snprintf(name, sizeof(name), "boot_services_data%d",
	327	+ type_count[md->type]++);
	328	+ break;
	329	+ default:
	330	+ continue;
	331	+ }
	332	+
	333	+ if (i >= EFI_DEBUGFS_MAX_BLOBS) {
	334	+ pr_warn("More then %d EFI boot service segments, only showing first %d in debugfs\n",
	335	+ EFI_DEBUGFS_MAX_BLOBS, EFI_DEBUGFS_MAX_BLOBS);
	336	+ break;
	337	+ }
	338	+
	339	+ debugfs_blob[i].size = md->num_pages << EFI_PAGE_SHIFT;
	340	+ debugfs_blob[i].data = memremap(md->phys_addr,
	341	+ debugfs_blob[i].size,
	342	+ MEMREMAP_WB);
	343	+ if (!debugfs_blob[i].data)
	344	+ continue;
	345	+
	346	+ debugfs_create_blob(name, 0400, efi_debugfs, &debugfs_blob[i]);
	347	+ i++;
	348	+ }
	349	+}
	350	+#else
	351	+static inline void efi_debugfs_init(void) {}
	352	+#endif
	353	+
337	354	/*
338	355	* We register the efi subsystem with the firmware subsystem and the
339	356	* efivars subsystem with the efi subsystem, if the system was booted with
..	..	@@ -343,20 +360,29 @@
343	360	{
344	361	int error;
345	362
	363	+ if (!efi_enabled(EFI_RUNTIME_SERVICES))
	364	+ efi.runtime_supported_mask = 0;
	365	+
346	366	if (!efi_enabled(EFI_BOOT))
347	367	return 0;
348	368
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;
	369	+ if (efi.runtime_supported_mask) {
	370	+ /*
	371	+ * Since we process only one efi_runtime_service() at a time, an
	372	+ * ordered workqueue (which creates only one execution context)
	373	+ * should suffice for all our needs.
	374	+ */
	375	+ efi_rts_wq = alloc_ordered_workqueue("efi_rts_wq", 0);
	376	+ if (!efi_rts_wq) {
	377	+ pr_err("Creating efi_rts_wq failed, EFI runtime services disabled.\n");
	378	+ clear_bit(EFI_RUNTIME_SERVICES, &efi.flags);
	379	+ efi.runtime_supported_mask = 0;
	380	+ return 0;
	381	+ }
359	382	}
	383	+
	384	+ if (efi_rt_services_supported(EFI_RT_SUPPORTED_TIME_SERVICES))
	385	+ platform_device_register_simple("rtc-efi", 0, NULL, 0);
360	386
361	387	/* We register the efi directory at /sys/firmware/efi */
362	388	efi_kobj = kobject_create_and_add("efi", firmware_kobj);
..	..	@@ -366,12 +392,14 @@
366	392	return -ENOMEM;
367	393	}
368	394
369		- error = generic_ops_register();
370		- if (error)
371		- goto err_put;
372		-
373		- if (efi_enabled(EFI_RUNTIME_SERVICES))
	395	+ if (efi_rt_services_supported(EFI_RT_SUPPORTED_GET_VARIABLE \|
	396	+ EFI_RT_SUPPORTED_GET_NEXT_VARIABLE_NAME)) {
	397	+ error = generic_ops_register();
	398	+ if (error)
	399	+ goto err_put;
374	400	efivar_ssdt_load();
	401	+ platform_device_register_simple("efivars", 0, NULL, 0);
	402	+ }
375	403
376	404	error = sysfs_create_group(efi_kobj, &efi_subsys_attr_group);
377	405	if (error) {
..	..	@@ -391,12 +419,17 @@
391	419	goto err_remove_group;
392	420	}
393	421
	422	+ if (efi_enabled(EFI_DBG) && efi_enabled(EFI_PRESERVE_BS_REGIONS))
	423	+ efi_debugfs_init();
	424	+
394	425	return 0;
395	426
396	427	err_remove_group:
397	428	sysfs_remove_group(efi_kobj, &efi_subsys_attr_group);
398	429	err_unregister:
399		- generic_ops_unregister();
	430	+ if (efi_rt_services_supported(EFI_RT_SUPPORTED_GET_VARIABLE \|
	431	+ EFI_RT_SUPPORTED_GET_NEXT_VARIABLE_NAME))
	432	+ generic_ops_unregister();
400	433	err_put:
401	434	kobject_put(efi_kobj);
402	435	destroy_workqueue(efi_rts_wq);
..	..	@@ -478,98 +511,99 @@
478	511	efi_arch_mem_reserve(addr, size);
479	512	}
480	513
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},
	514	+static const efi_config_table_type_t common_tables[] __initconst = {
	515	+ {ACPI_20_TABLE_GUID, &efi.acpi20, "ACPI 2.0" },
	516	+ {ACPI_TABLE_GUID, &efi.acpi, "ACPI" },
	517	+ {SMBIOS_TABLE_GUID, &efi.smbios, "SMBIOS" },
	518	+ {SMBIOS3_TABLE_GUID, &efi.smbios3, "SMBIOS 3.0" },
	519	+ {EFI_SYSTEM_RESOURCE_TABLE_GUID, &efi.esrt, "ESRT" },
	520	+ {EFI_MEMORY_ATTRIBUTES_TABLE_GUID, &efi_mem_attr_table, "MEMATTR" },
	521	+ {LINUX_EFI_RANDOM_SEED_TABLE_GUID, &efi_rng_seed, "RNG" },
	522	+ {LINUX_EFI_TPM_EVENT_LOG_GUID, &efi.tpm_log, "TPMEventLog" },
	523	+ {LINUX_EFI_TPM_FINAL_LOG_GUID, &efi.tpm_final_log, "TPMFinalLog" },
	524	+ {LINUX_EFI_MEMRESERVE_TABLE_GUID, &mem_reserve, "MEMRESERVE" },
	525	+ {EFI_RT_PROPERTIES_TABLE_GUID, &rt_prop, "RTPROP" },
	526	+#ifdef CONFIG_EFI_RCI2_TABLE
	527	+ {DELLEMC_EFI_RCI2_TABLE_GUID, &rci2_table_phys },
	528	+#endif
	529	+#ifdef CONFIG_LOAD_UEFI_KEYS
	530	+ {LINUX_EFI_MOK_VARIABLE_TABLE_GUID, &efi.mokvar_table, "MOKvar" },
	531	+#endif
	532	+ {},
496	533	};
497	534
498		-static __init int match_config_table(efi_guid_t *guid,
	535	+static __init int match_config_table(const efi_guid_t *guid,
499	536	unsigned long table,
500		- efi_config_table_type_t *table_types)
	537	+ const efi_config_table_type_t *table_types)
501	538	{
502	539	int i;
503	540
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		- }
	541	+ for (i = 0; efi_guidcmp(table_types[i].guid, NULL_GUID); i++) {
	542	+ if (!efi_guidcmp(*guid, table_types[i].guid)) {
	543	+ *(table_types[i].ptr) = table;
	544	+ if (table_types[i].name[0])
	545	+ pr_cont("%s=0x%lx ",
	546	+ table_types[i].name, table);
	547	+ return 1;
513	548	}
514	549	}
515	550
516	551	return 0;
517	552	}
518	553
519		-int __init efi_config_parse_tables(void *config_tables, int count, int sz,
520		- efi_config_table_type_t *arch_tables)
	554	+int __init efi_config_parse_tables(const efi_config_table_t *config_tables,
	555	+ int count,
	556	+ const efi_config_table_type_t *arch_tables)
521	557	{
522		- void *tablep;
	558	+ const efi_config_table_64_t tbl64 = (void )config_tables;
	559	+ const efi_config_table_32_t tbl32 = (void )config_tables;
	560	+ const efi_guid_t *guid;
	561	+ unsigned long table;
523	562	int i;
524	563
525		- tablep = config_tables;
526	564	pr_info("");
527	565	for (i = 0; i < count; i++) {
528		- efi_guid_t guid;
529		- unsigned long table;
	566	+ if (!IS_ENABLED(CONFIG_X86)) {
	567	+ guid = &config_tables[i].guid;
	568	+ table = (unsigned long)config_tables[i].table;
	569	+ } else if (efi_enabled(EFI_64BIT)) {
	570	+ guid = &tbl64[i].guid;
	571	+ table = tbl64[i].table;
530	572
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) {
	573	+ if (IS_ENABLED(CONFIG_X86_32) &&
	574	+ tbl64[i].table > U32_MAX) {
538	575	pr_cont("\n");
539	576	pr_err("Table located above 4GB, disabling EFI.\n");
540	577	return -EINVAL;
541	578	}
542		-#endif
543	579	} else {
544		- guid = ((efi_config_table_32_t *)tablep)->guid;
545		- table = ((efi_config_table_32_t *)tablep)->table;
	580	+ guid = &tbl32[i].guid;
	581	+ table = tbl32[i].table;
546	582	}
547	583
548		- if (!match_config_table(&guid, table, common_tables))
549		- match_config_table(&guid, table, arch_tables);
550		-
551		- tablep += sz;
	584	+ if (!match_config_table(guid, table, common_tables) && arch_tables)
	585	+ match_config_table(guid, table, arch_tables);
552	586	}
553	587	pr_cont("\n");
554	588	set_bit(EFI_CONFIG_TABLES, &efi.flags);
555	589
556		- if (efi.rng_seed != EFI_INVALID_TABLE_ADDR) {
	590	+ if (efi_rng_seed != EFI_INVALID_TABLE_ADDR) {
557	591	struct linux_efi_random_seed *seed;
558	592	u32 size = 0;
559	593
560		- seed = early_memremap(efi.rng_seed, sizeof(*seed));
	594	+ seed = early_memremap(efi_rng_seed, sizeof(*seed));
561	595	if (seed != NULL) {
562		- size = seed->size;
	596	+ size = min(seed->size, EFI_RANDOM_SEED_SIZE);
563	597	early_memunmap(seed, sizeof(*seed));
564	598	} else {
565	599	pr_err("Could not map UEFI random seed!\n");
566	600	}
567	601	if (size > 0) {
568		- seed = early_memremap(efi.rng_seed,
	602	+ seed = early_memremap(efi_rng_seed,
569	603	sizeof(*seed) + size);
570	604	if (seed != NULL) {
571	605	pr_notice("seeding entropy pool\n");
572		- add_device_randomness(seed->bits, seed->size);
	606	+ add_bootloader_randomness(seed->bits, size);
573	607	early_memunmap(seed, sizeof(*seed) + size);
574	608	} else {
575	609	pr_err("Could not map UEFI random seed!\n");
..	..	@@ -582,202 +616,122 @@
582	616
583	617	efi_tpm_eventlog_init();
584	618
585		- /* Parse the EFI Properties table if it exists */
586		- if (efi.properties_table != EFI_INVALID_TABLE_ADDR) {
587		- efi_properties_table_t *tbl;
	619	+ if (mem_reserve != EFI_INVALID_TABLE_ADDR) {
	620	+ unsigned long prsv = mem_reserve;
588	621
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;
	622	+ while (prsv) {
	623	+ struct linux_efi_memreserve *rsv;
	624	+ u8 *p;
	625	+
	626	+ /*
	627	+ * Just map a full page: that is what we will get
	628	+ * anyway, and it permits us to map the entire entry
	629	+ * before knowing its size.
	630	+ */
	631	+ p = early_memremap(ALIGN_DOWN(prsv, PAGE_SIZE),
	632	+ PAGE_SIZE);
	633	+ if (p == NULL) {
	634	+ pr_err("Could not map UEFI memreserve entry!\n");
	635	+ return -ENOMEM;
	636	+ }
	637	+
	638	+ rsv = (void *)(p + prsv % PAGE_SIZE);
	639	+
	640	+ /* reserve the entry itself */
	641	+ memblock_reserve(prsv,
	642	+ struct_size(rsv, entry, rsv->size));
	643	+
	644	+ for (i = 0; i < atomic_read(&rsv->count); i++) {
	645	+ memblock_reserve(rsv->entry[i].base,
	646	+ rsv->entry[i].size);
	647	+ }
	648	+
	649	+ prsv = rsv->next;
	650	+ early_memunmap(p, PAGE_SIZE);
593	651	}
	652	+ }
594	653
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);
	654	+ if (rt_prop != EFI_INVALID_TABLE_ADDR) {
	655	+ efi_rt_properties_table_t *tbl;
598	656
599		- early_memunmap(tbl, sizeof(*tbl));
	657	+ tbl = early_memremap(rt_prop, sizeof(*tbl));
	658	+ if (tbl) {
	659	+ efi.runtime_supported_mask &= tbl->runtime_services_supported;
	660	+ early_memunmap(tbl, sizeof(*tbl));
	661	+ }
600	662	}
601	663
602	664	return 0;
603	665	}
604	666
605		-int __init efi_config_init(efi_config_table_type_t *arch_tables)
	667	+int __init efi_systab_check_header(const efi_table_hdr_t *systab_hdr,
	668	+ int min_major_version)
606	669	{
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;
	670	+ if (systab_hdr->signature != EFI_SYSTEM_TABLE_SIGNATURE) {
	671	+ pr_err("System table signature incorrect!\n");
	672	+ return -EINVAL;
623	673	}
624	674
625		- ret = efi_config_parse_tables(config_tables, efi.systab->nr_tables, sz,
626		- arch_tables);
	675	+ if ((systab_hdr->revision >> 16) < min_major_version)
	676	+ pr_err("Warning: System table version %d.%02d, expected %d.00 or greater!\n",
	677	+ systab_hdr->revision >> 16,
	678	+ systab_hdr->revision & 0xffff,
	679	+ min_major_version);
627	680
628		- early_memunmap(config_tables, efi.systab->nr_tables * sz);
	681	+ return 0;
	682	+}
	683	+
	684	+#ifndef CONFIG_IA64
	685	+static const efi_char16_t *__init map_fw_vendor(unsigned long fw_vendor,
	686	+ size_t size)
	687	+{
	688	+ const efi_char16_t *ret;
	689	+
	690	+ ret = early_memremap_ro(fw_vendor, size);
	691	+ if (!ret)
	692	+ pr_err("Could not map the firmware vendor!\n");
629	693	return ret;
630	694	}
631	695
632		-#ifdef CONFIG_EFI_VARS_MODULE
633		-static int __init efi_load_efivars(void)
	696	+static void __init unmap_fw_vendor(const void *fw_vendor, size_t size)
634	697	{
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);
	698	+ early_memunmap((void *)fw_vendor, size);
642	699	}
643		-device_initcall(efi_load_efivars);
	700	+#else
	701	+#define map_fw_vendor(p, s) __va(p)
	702	+#define unmap_fw_vendor(v, s)
644	703	#endif
645	704
646		-#ifdef CONFIG_EFI_PARAMS_FROM_FDT
	705	+void __init efi_systab_report_header(const efi_table_hdr_t *systab_hdr,
	706	+ unsigned long fw_vendor)
	707	+{
	708	+ char vendor[100] = "unknown";
	709	+ const efi_char16_t *c16;
	710	+ size_t i;
647	711
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) \
	712	+ c16 = map_fw_vendor(fw_vendor, sizeof(vendor) * sizeof(efi_char16_t));
	713	+ if (c16) {
	714	+ for (i = 0; i < sizeof(vendor) - 1 && c16[i]; ++i)
	715	+ vendor[i] = c16[i];
	716	+ vendor[i] = '\0';
	717	+
	718	+ unmap_fw_vendor(c16, sizeof(vendor) * sizeof(efi_char16_t));
654	719	}
655	720
656		-struct params {
657		- const char name[32];
658		- const char propname[32];
659		- int offset;
660		- int size;
661		-};
	721	+ pr_info("EFI v%u.%.02u by %s\n",
	722	+ systab_hdr->revision >> 16,
	723	+ systab_hdr->revision & 0xffff,
	724	+ vendor);
662	725
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);
	726	+ if (IS_ENABLED(CONFIG_X86_64) &&
	727	+ systab_hdr->revision > EFI_1_10_SYSTEM_TABLE_REVISION &&
	728	+ !strcmp(vendor, "Apple")) {
	729	+ pr_info("Apple Mac detected, using EFI v1.10 runtime services only\n");
	730	+ efi.runtime_version = EFI_1_10_SYSTEM_TABLE_REVISION;
725	731	}
726		-
727		- return 1;
728	732	}
729	733
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] = {
	734	+static __initdata char memory_type_name[][13] = {
781	735	"Reserved",
782	736	"Loader Code",
783	737	"Loader Data",
..	..	@@ -785,14 +739,14 @@
785	739	"Boot Data",
786	740	"Runtime Code",
787	741	"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",
	742	+ "Conventional",
	743	+ "Unusable",
	744	+ "ACPI Reclaim",
	745	+ "ACPI Mem NVS",
	746	+ "MMIO",
	747	+ "MMIO Port",
794	748	"PAL Code",
795		- "Persistent Memory",
	749	+ "Persistent",
796	750	};
797	751
798	752	char * __init efi_md_typeattr_format(char *buf, size_t size,
..	..	@@ -819,25 +773,27 @@
819	773	if (attr & ~(EFI_MEMORY_UC \| EFI_MEMORY_WC \| EFI_MEMORY_WT \|
820	774	EFI_MEMORY_WB \| EFI_MEMORY_UCE \| EFI_MEMORY_RO \|
821	775	EFI_MEMORY_WP \| EFI_MEMORY_RP \| EFI_MEMORY_XP \|
822		- EFI_MEMORY_NV \|
	776	+ EFI_MEMORY_NV \| EFI_MEMORY_SP \| EFI_MEMORY_CPU_CRYPTO \|
823	777	EFI_MEMORY_RUNTIME \| EFI_MEMORY_MORE_RELIABLE))
824	778	snprintf(pos, size, "\|attr=0x%016llx]",
825	779	(unsigned long long)attr);
826	780	else
827	781	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" : "");
	782	+ "\|%3s\|%2s\|%2s\|%2s\|%2s\|%2s\|%2s\|%2s\|%2s\|%3s\|%2s\|%2s\|%2s\|%2s]",
	783	+ attr & EFI_MEMORY_RUNTIME ? "RUN" : "",
	784	+ attr & EFI_MEMORY_MORE_RELIABLE ? "MR" : "",
	785	+ attr & EFI_MEMORY_CPU_CRYPTO ? "CC" : "",
	786	+ attr & EFI_MEMORY_SP ? "SP" : "",
	787	+ attr & EFI_MEMORY_NV ? "NV" : "",
	788	+ attr & EFI_MEMORY_XP ? "XP" : "",
	789	+ attr & EFI_MEMORY_RP ? "RP" : "",
	790	+ attr & EFI_MEMORY_WP ? "WP" : "",
	791	+ attr & EFI_MEMORY_RO ? "RO" : "",
	792	+ attr & EFI_MEMORY_UCE ? "UCE" : "",
	793	+ attr & EFI_MEMORY_WB ? "WB" : "",
	794	+ attr & EFI_MEMORY_WT ? "WT" : "",
	795	+ attr & EFI_MEMORY_WC ? "WC" : "",
	796	+ attr & EFI_MEMORY_UC ? "UC" : "");
841	797	return buf;
842	798	}
843	799
..	..	@@ -876,7 +832,7 @@
876	832	*
877	833	* Search in the EFI memory map for the region covering @phys_addr.
878	834	* Returns the EFI memory type if the region was found in the memory
879		- * map, EFI_RESERVED_TYPE (zero) otherwise.
	835	+ * map, -EINVAL otherwise.
880	836	*/
881	837	int efi_mem_type(unsigned long phys_addr)
882	838	{
..	..	@@ -931,19 +887,120 @@
931	887	return err;
932	888	}
933	889
934		-bool efi_is_table_address(unsigned long phys_addr)
	890	+static DEFINE_SPINLOCK(efi_mem_reserve_persistent_lock);
	891	+static struct linux_efi_memreserve *efi_memreserve_root __ro_after_init;
	892	+
	893	+static int __init efi_memreserve_map_root(void)
935	894	{
936		- unsigned int i;
	895	+ if (mem_reserve == EFI_INVALID_TABLE_ADDR)
	896	+ return -ENODEV;
937	897
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;
	898	+ efi_memreserve_root = memremap(mem_reserve,
	899	+ sizeof(*efi_memreserve_root),
	900	+ MEMREMAP_WB);
	901	+ if (WARN_ON_ONCE(!efi_memreserve_root))
	902	+ return -ENOMEM;
	903	+ return 0;
946	904	}
	905	+
	906	+static int efi_mem_reserve_iomem(phys_addr_t addr, u64 size)
	907	+{
	908	+ struct resource res, parent;
	909	+ int ret;
	910	+
	911	+ res = kzalloc(sizeof(struct resource), GFP_ATOMIC);
	912	+ if (!res)
	913	+ return -ENOMEM;
	914	+
	915	+ res->name = "reserved";
	916	+ res->flags = IORESOURCE_MEM;
	917	+ res->start = addr;
	918	+ res->end = addr + size - 1;
	919	+
	920	+ /* we expect a conflict with a 'System RAM' region */
	921	+ parent = request_resource_conflict(&iomem_resource, res);
	922	+ ret = parent ? request_resource(parent, res) : 0;
	923	+
	924	+ /*
	925	+ * Given that efi_mem_reserve_iomem() can be called at any
	926	+ * time, only call memblock_reserve() if the architecture
	927	+ * keeps the infrastructure around.
	928	+ */
	929	+ if (IS_ENABLED(CONFIG_ARCH_KEEP_MEMBLOCK) && !ret)
	930	+ memblock_reserve(addr, size);
	931	+
	932	+ return ret;
	933	+}
	934	+
	935	+int __ref efi_mem_reserve_persistent(phys_addr_t addr, u64 size)
	936	+{
	937	+ struct linux_efi_memreserve *rsv;
	938	+ unsigned long prsv;
	939	+ int rc, index;
	940	+
	941	+ if (efi_memreserve_root == (void *)ULONG_MAX)
	942	+ return -ENODEV;
	943	+
	944	+ if (!efi_memreserve_root) {
	945	+ rc = efi_memreserve_map_root();
	946	+ if (rc)
	947	+ return rc;
	948	+ }
	949	+
	950	+ /* first try to find a slot in an existing linked list entry */
	951	+ for (prsv = efi_memreserve_root->next; prsv; ) {
	952	+ rsv = memremap(prsv, sizeof(*rsv), MEMREMAP_WB);
	953	+ index = atomic_fetch_add_unless(&rsv->count, 1, rsv->size);
	954	+ if (index < rsv->size) {
	955	+ rsv->entry[index].base = addr;
	956	+ rsv->entry[index].size = size;
	957	+
	958	+ memunmap(rsv);
	959	+ return efi_mem_reserve_iomem(addr, size);
	960	+ }
	961	+ prsv = rsv->next;
	962	+ memunmap(rsv);
	963	+ }
	964	+
	965	+ /* no slot found - allocate a new linked list entry */
	966	+ rsv = (struct linux_efi_memreserve *)__get_free_page(GFP_ATOMIC);
	967	+ if (!rsv)
	968	+ return -ENOMEM;
	969	+
	970	+ rc = efi_mem_reserve_iomem(__pa(rsv), SZ_4K);
	971	+ if (rc) {
	972	+ free_page((unsigned long)rsv);
	973	+ return rc;
	974	+ }
	975	+
	976	+ /*
	977	+ * The memremap() call above assumes that a linux_efi_memreserve entry
	978	+ * never crosses a page boundary, so let's ensure that this remains true
	979	+ * even when kexec'ing a 4k pages kernel from a >4k pages kernel, by
	980	+ * using SZ_4K explicitly in the size calculation below.
	981	+ */
	982	+ rsv->size = EFI_MEMRESERVE_COUNT(SZ_4K);
	983	+ atomic_set(&rsv->count, 1);
	984	+ rsv->entry[0].base = addr;
	985	+ rsv->entry[0].size = size;
	986	+
	987	+ spin_lock(&efi_mem_reserve_persistent_lock);
	988	+ rsv->next = efi_memreserve_root->next;
	989	+ efi_memreserve_root->next = __pa(rsv);
	990	+ spin_unlock(&efi_mem_reserve_persistent_lock);
	991	+
	992	+ return efi_mem_reserve_iomem(addr, size);
	993	+}
	994	+
	995	+static int __init efi_memreserve_root_init(void)
	996	+{
	997	+ if (efi_memreserve_root)
	998	+ return 0;
	999	+ if (efi_memreserve_map_root())
	1000	+ efi_memreserve_root = (void *)ULONG_MAX;
	1001	+ return 0;
	1002	+}
	1003	+early_initcall(efi_memreserve_root_init);
947	1004
948	1005	#ifdef CONFIG_KEXEC
949	1006	static int update_efi_random_seed(struct notifier_block *nb,
..	..	@@ -955,7 +1012,7 @@
955	1012	if (!kexec_in_progress)
956	1013	return NOTIFY_DONE;
957	1014
958		- seed = memremap(efi.rng_seed, sizeof(*seed), MEMREMAP_WB);
	1015	+ seed = memremap(efi_rng_seed, sizeof(*seed), MEMREMAP_WB);
959	1016	if (seed != NULL) {
960	1017	size = min(seed->size, EFI_RANDOM_SEED_SIZE);
961	1018	memunmap(seed);
..	..	@@ -963,7 +1020,7 @@
963	1020	pr_err("Could not map UEFI random seed!\n");
964	1021	}
965	1022	if (size > 0) {
966		- seed = memremap(efi.rng_seed, sizeof(*seed) + size,
	1023	+ seed = memremap(efi_rng_seed, sizeof(*seed) + size,
967	1024	MEMREMAP_WB);
968	1025	if (seed != NULL) {
969	1026	seed->size = size;
..	..	@@ -980,9 +1037,9 @@
980	1037	.notifier_call = update_efi_random_seed,
981	1038	};
982	1039
983		-static int register_update_efi_random_seed(void)
	1040	+static int __init register_update_efi_random_seed(void)
984	1041	{
985		- if (efi.rng_seed == EFI_INVALID_TABLE_ADDR)
	1042	+ if (efi_rng_seed == EFI_INVALID_TABLE_ADDR)
986	1043	return 0;
987	1044	return register_reboot_notifier(&efi_random_seed_nb);
988	1045	}