1// SPDX-License-Identifier: GPL-2.0
2#define BOOT_CTYPE_H
3#include "misc.h"
4#include "error.h"
5#include "../string.h"
6#include "efi.h"
7
8#include <asm/bootparam.h>
9
10#include <linux/numa.h>
11
12/*
13 * Longest parameter of 'acpi=' is 'copy_dsdt', plus an extra '\0'
14 * for termination.
15 */
16#define MAX_ACPI_ARG_LENGTH 10
17
18/*
19 * Immovable memory regions representation. Max amount of memory regions is
20 * MAX_NUMNODES*2.
21 */
22struct mem_vector immovable_mem[MAX_NUMNODES*2];
23
24static acpi_physical_address
25__efi_get_rsdp_addr(unsigned long cfg_tbl_pa, unsigned int cfg_tbl_len)
26{
27#ifdef CONFIG_EFI
28	unsigned long rsdp_addr;
29	int ret;
30
31	/*
32	 * Search EFI system tables for RSDP. Preferred is ACPI_20_TABLE_GUID to
33	 * ACPI_TABLE_GUID because it has more features.
34	 */
35	rsdp_addr = efi_find_vendor_table(boot_params_ptr, cfg_tbl_pa, cfg_tbl_len,
36					  ACPI_20_TABLE_GUID);
37	if (rsdp_addr)
38		return (acpi_physical_address)rsdp_addr;
39
40	/* No ACPI_20_TABLE_GUID found, fallback to ACPI_TABLE_GUID. */
41	rsdp_addr = efi_find_vendor_table(boot_params_ptr, cfg_tbl_pa, cfg_tbl_len,
42					  ACPI_TABLE_GUID);
43	if (rsdp_addr)
44		return (acpi_physical_address)rsdp_addr;
45
46	debug_putstr("Error getting RSDP address.\n");
47#endif
48	return 0;
49}
50
51static acpi_physical_address efi_get_rsdp_addr(void)
52{
53#ifdef CONFIG_EFI
54	unsigned long cfg_tbl_pa = 0;
55	unsigned int cfg_tbl_len;
56	unsigned long systab_pa;
57	unsigned int nr_tables;
58	enum efi_type et;
59	int ret;
60
61	et = efi_get_type(boot_params_ptr);
62	if (et == EFI_TYPE_NONE)
63		return 0;
64
65	systab_pa = efi_get_system_table(boot_params_ptr);
66	if (!systab_pa)
67		error("EFI support advertised, but unable to locate system table.");
68
69	ret = efi_get_conf_table(boot_params_ptr, &cfg_tbl_pa, &cfg_tbl_len);
70	if (ret || !cfg_tbl_pa)
71		error("EFI config table not found.");
72
73	return __efi_get_rsdp_addr(cfg_tbl_pa, cfg_tbl_len);
74#else
75	return 0;
76#endif
77}
78
79static u8 compute_checksum(u8 *buffer, u32 length)
80{
81	u8 *end = buffer + length;
82	u8 sum = 0;
83
84	while (buffer < end)
85		sum += *(buffer++);
86
87	return sum;
88}
89
90/* Search a block of memory for the RSDP signature. */
91static u8 *scan_mem_for_rsdp(u8 *start, u32 length)
92{
93	struct acpi_table_rsdp *rsdp;
94	u8 *address, *end;
95
96	end = start + length;
97
98	/* Search from given start address for the requested length */
99	for (address = start; address < end; address += ACPI_RSDP_SCAN_STEP) {
100		/*
101		 * Both RSDP signature and checksum must be correct.
102		 * Note: Sometimes there exists more than one RSDP in memory;
103		 * the valid RSDP has a valid checksum, all others have an
104		 * invalid checksum.
105		 */
106		rsdp = (struct acpi_table_rsdp *)address;
107
108		/* BAD Signature */
109		if (!ACPI_VALIDATE_RSDP_SIG(rsdp->signature))
110			continue;
111
112		/* Check the standard checksum */
113		if (compute_checksum((u8 *)rsdp, ACPI_RSDP_CHECKSUM_LENGTH))
114			continue;
115
116		/* Check extended checksum if table version >= 2 */
117		if ((rsdp->revision >= 2) &&
118		    (compute_checksum((u8 *)rsdp, ACPI_RSDP_XCHECKSUM_LENGTH)))
119			continue;
120
121		/* Signature and checksum valid, we have found a real RSDP */
122		return address;
123	}
124	return NULL;
125}
126
127/* Search RSDP address in EBDA. */
128static acpi_physical_address bios_get_rsdp_addr(void)
129{
130	unsigned long address;
131	u8 *rsdp;
132
133	/* Get the location of the Extended BIOS Data Area (EBDA) */
134	address = *(u16 *)ACPI_EBDA_PTR_LOCATION;
135	address <<= 4;
136
137	/*
138	 * Search EBDA paragraphs (EBDA is required to be a minimum of
139	 * 1K length)
140	 */
141	if (address > 0x400) {
142		rsdp = scan_mem_for_rsdp((u8 *)address, ACPI_EBDA_WINDOW_SIZE);
143		if (rsdp)
144			return (acpi_physical_address)(unsigned long)rsdp;
145	}
146
147	/* Search upper memory: 16-byte boundaries in E0000h-FFFFFh */
148	rsdp = scan_mem_for_rsdp((u8 *) ACPI_HI_RSDP_WINDOW_BASE,
149					ACPI_HI_RSDP_WINDOW_SIZE);
150	if (rsdp)
151		return (acpi_physical_address)(unsigned long)rsdp;
152
153	return 0;
154}
155
156/* Return RSDP address on success, otherwise 0. */
157acpi_physical_address get_rsdp_addr(void)
158{
159	acpi_physical_address pa;
160
161	pa = boot_params_ptr->acpi_rsdp_addr;
162
163	if (!pa)
164		pa = efi_get_rsdp_addr();
165
166	if (!pa)
167		pa = bios_get_rsdp_addr();
168
169	return pa;
170}
171
172#if defined(CONFIG_RANDOMIZE_BASE) && defined(CONFIG_MEMORY_HOTREMOVE)
173/*
174 * Max length of 64-bit hex address string is 19, prefix "0x" + 16 hex
175 * digits, and '\0' for termination.
176 */
177#define MAX_ADDR_LEN 19
178
179static unsigned long get_cmdline_acpi_rsdp(void)
180{
181	unsigned long addr = 0;
182
183#ifdef CONFIG_KEXEC_CORE
184	char val[MAX_ADDR_LEN] = { };
185	int ret;
186
187	ret = cmdline_find_option("acpi_rsdp", val, MAX_ADDR_LEN);
188	if (ret < 0)
189		return 0;
190
191	if (boot_kstrtoul(val, 16, &addr))
192		return 0;
193#endif
194	return addr;
195}
196
197/* Compute SRAT address from RSDP. */
198static unsigned long get_acpi_srat_table(void)
199{
200	unsigned long root_table, acpi_table;
201	struct acpi_table_header *header;
202	struct acpi_table_rsdp *rsdp;
203	u32 num_entries, size, len;
204	char arg[10];
205	u8 *entry;
206
207	/*
208	 * Check whether we were given an RSDP on the command line. We don't
209	 * stash this in boot params because the kernel itself may have
210	 * different ideas about whether to trust a command-line parameter.
211	 */
212	rsdp = (struct acpi_table_rsdp *)get_cmdline_acpi_rsdp();
213	if (!rsdp)
214		rsdp = (struct acpi_table_rsdp *)(long)
215			boot_params_ptr->acpi_rsdp_addr;
216
217	if (!rsdp)
218		return 0;
219
220	/* Get ACPI root table from RSDP.*/
221	if (!(cmdline_find_option("acpi", arg, sizeof(arg)) == 4 &&
222	    !strncmp(arg, "rsdt", 4)) &&
223	    rsdp->xsdt_physical_address &&
224	    rsdp->revision > 1) {
225		root_table = rsdp->xsdt_physical_address;
226		size = ACPI_XSDT_ENTRY_SIZE;
227	} else {
228		root_table = rsdp->rsdt_physical_address;
229		size = ACPI_RSDT_ENTRY_SIZE;
230	}
231
232	if (!root_table)
233		return 0;
234
235	header = (struct acpi_table_header *)root_table;
236	len = header->length;
237	if (len < sizeof(struct acpi_table_header) + size)
238		return 0;
239
240	num_entries = (len - sizeof(struct acpi_table_header)) / size;
241	entry = (u8 *)(root_table + sizeof(struct acpi_table_header));
242
243	while (num_entries--) {
244		if (size == ACPI_RSDT_ENTRY_SIZE)
245			acpi_table = *(u32 *)entry;
246		else
247			acpi_table = *(u64 *)entry;
248
249		if (acpi_table) {
250			header = (struct acpi_table_header *)acpi_table;
251
252			if (ACPI_COMPARE_NAMESEG(header->signature, ACPI_SIG_SRAT))
253				return acpi_table;
254		}
255		entry += size;
256	}
257	return 0;
258}
259
260/**
261 * count_immovable_mem_regions - Parse SRAT and cache the immovable
262 * memory regions into the immovable_mem array.
263 *
264 * Return the number of immovable memory regions on success, 0 on failure:
265 *
266 * - Too many immovable memory regions
267 * - ACPI off or no SRAT found
268 * - No immovable memory region found.
269 */
270int count_immovable_mem_regions(void)
271{
272	unsigned long table_addr, table_end, table;
273	struct acpi_subtable_header *sub_table;
274	struct acpi_table_header *table_header;
275	char arg[MAX_ACPI_ARG_LENGTH];
276	int num = 0;
277
278	if (cmdline_find_option("acpi", arg, sizeof(arg)) == 3 &&
279	    !strncmp(arg, "off", 3))
280		return 0;
281
282	table_addr = get_acpi_srat_table();
283	if (!table_addr)
284		return 0;
285
286	table_header = (struct acpi_table_header *)table_addr;
287	table_end = table_addr + table_header->length;
288	table = table_addr + sizeof(struct acpi_table_srat);
289
290	while (table + sizeof(struct acpi_subtable_header) < table_end) {
291
292		sub_table = (struct acpi_subtable_header *)table;
293		if (!sub_table->length) {
294			debug_putstr("Invalid zero length SRAT subtable.\n");
295			return 0;
296		}
297
298		if (sub_table->type == ACPI_SRAT_TYPE_MEMORY_AFFINITY) {
299			struct acpi_srat_mem_affinity *ma;
300
301			ma = (struct acpi_srat_mem_affinity *)sub_table;
302			if (!(ma->flags & ACPI_SRAT_MEM_HOT_PLUGGABLE) && ma->length) {
303				immovable_mem[num].start = ma->base_address;
304				immovable_mem[num].size = ma->length;
305				num++;
306			}
307
308			if (num >= MAX_NUMNODES*2) {
309				debug_putstr("Too many immovable memory regions, aborting.\n");
310				return 0;
311			}
312		}
313		table += sub_table->length;
314	}
315	return num;
316}
317#endif /* CONFIG_RANDOMIZE_BASE && CONFIG_MEMORY_HOTREMOVE */
318