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 | */ |
22 | struct mem_vector immovable_mem[MAX_NUMNODES*2]; |
23 | |
24 | static 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(bp: 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(bp: 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 | |
51 | static 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(bp: boot_params_ptr); |
62 | if (et == EFI_TYPE_NONE) |
63 | return 0; |
64 | |
65 | systab_pa = efi_get_system_table(bp: boot_params_ptr); |
66 | if (!systab_pa) |
67 | error(m: "EFI support advertised, but unable to locate system table." ); |
68 | |
69 | ret = efi_get_conf_table(bp: boot_params_ptr, cfg_tbl_pa: &cfg_tbl_pa, cfg_tbl_len: &cfg_tbl_len); |
70 | if (ret || !cfg_tbl_pa) |
71 | error(m: "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 | |
79 | static 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. */ |
91 | static 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(buffer: (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(buffer: (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. */ |
128 | static 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(start: (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(start: (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. */ |
157 | acpi_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 | |
179 | static 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(option: "acpi_rsdp" , buffer: val, MAX_ADDR_LEN); |
188 | if (ret < 0) |
189 | return 0; |
190 | |
191 | if (boot_kstrtoul(s: val, base: 16, res: &addr)) |
192 | return 0; |
193 | #endif |
194 | return addr; |
195 | } |
196 | |
197 | /* Compute SRAT address from RSDP. */ |
198 | static unsigned long get_acpi_srat_table(void) |
199 | { |
200 | unsigned long root_table, acpi_table; |
201 | struct acpi_table_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(option: "acpi" , buffer: arg, bufsize: sizeof(arg)) == 4 && |
222 | !strncmp(cs: arg, ct: "rsdt" , count: 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 | */ |
270 | int 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 *; |
275 | char arg[MAX_ACPI_ARG_LENGTH]; |
276 | int num = 0; |
277 | |
278 | if (cmdline_find_option(option: "acpi" , buffer: arg, bufsize: sizeof(arg)) == 3 && |
279 | !strncmp(cs: arg, ct: "off" , count: 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 | |