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