1 | // SPDX-License-Identifier: GPL-2.0-or-later |
2 | /* |
3 | * acpi_tables.c - ACPI Boot-Time Table Parsing |
4 | * |
5 | * Copyright (C) 2001 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com> |
6 | */ |
7 | |
8 | /* Uncomment next line to get verbose printout */ |
9 | /* #define DEBUG */ |
10 | #define pr_fmt(fmt) "ACPI: " fmt |
11 | |
12 | #include <linux/init.h> |
13 | #include <linux/kernel.h> |
14 | #include <linux/smp.h> |
15 | #include <linux/string.h> |
16 | #include <linux/types.h> |
17 | #include <linux/irq.h> |
18 | #include <linux/errno.h> |
19 | #include <linux/acpi.h> |
20 | #include <linux/memblock.h> |
21 | #include <linux/earlycpio.h> |
22 | #include <linux/initrd.h> |
23 | #include <linux/security.h> |
24 | #include <linux/kmemleak.h> |
25 | #include "internal.h" |
26 | |
27 | #ifdef CONFIG_ACPI_CUSTOM_DSDT |
28 | #include CONFIG_ACPI_CUSTOM_DSDT_FILE |
29 | #endif |
30 | |
31 | #define ACPI_MAX_TABLES 128 |
32 | |
33 | static char *mps_inti_flags_polarity[] = { "dfl" , "high" , "res" , "low" }; |
34 | static char *mps_inti_flags_trigger[] = { "dfl" , "edge" , "res" , "level" }; |
35 | |
36 | static struct acpi_table_desc initial_tables[ACPI_MAX_TABLES] __initdata; |
37 | |
38 | static int acpi_apic_instance __initdata_or_acpilib; |
39 | |
40 | /* |
41 | * Disable table checksum verification for the early stage due to the size |
42 | * limitation of the current x86 early mapping implementation. |
43 | */ |
44 | static bool acpi_verify_table_checksum __initdata_or_acpilib = false; |
45 | |
46 | void acpi_table_print_madt_entry(struct acpi_subtable_header *) |
47 | { |
48 | if (!header) |
49 | return; |
50 | |
51 | switch (header->type) { |
52 | |
53 | case ACPI_MADT_TYPE_LOCAL_APIC: |
54 | { |
55 | struct acpi_madt_local_apic *p = |
56 | (struct acpi_madt_local_apic *)header; |
57 | pr_debug("LAPIC (acpi_id[0x%02x] lapic_id[0x%02x] %s)\n" , |
58 | p->processor_id, p->id, |
59 | (p->lapic_flags & ACPI_MADT_ENABLED) ? "enabled" : "disabled" ); |
60 | } |
61 | break; |
62 | |
63 | case ACPI_MADT_TYPE_LOCAL_X2APIC: |
64 | { |
65 | struct acpi_madt_local_x2apic *p = |
66 | (struct acpi_madt_local_x2apic *)header; |
67 | pr_debug("X2APIC (apic_id[0x%02x] uid[0x%02x] %s)\n" , |
68 | p->local_apic_id, p->uid, |
69 | (p->lapic_flags & ACPI_MADT_ENABLED) ? "enabled" : "disabled" ); |
70 | } |
71 | break; |
72 | |
73 | case ACPI_MADT_TYPE_IO_APIC: |
74 | { |
75 | struct acpi_madt_io_apic *p = |
76 | (struct acpi_madt_io_apic *)header; |
77 | pr_debug("IOAPIC (id[0x%02x] address[0x%08x] gsi_base[%d])\n" , |
78 | p->id, p->address, p->global_irq_base); |
79 | } |
80 | break; |
81 | |
82 | case ACPI_MADT_TYPE_INTERRUPT_OVERRIDE: |
83 | { |
84 | struct acpi_madt_interrupt_override *p = |
85 | (struct acpi_madt_interrupt_override *)header; |
86 | pr_info("INT_SRC_OVR (bus %d bus_irq %d global_irq %d %s %s)\n" , |
87 | p->bus, p->source_irq, p->global_irq, |
88 | mps_inti_flags_polarity[p->inti_flags & ACPI_MADT_POLARITY_MASK], |
89 | mps_inti_flags_trigger[(p->inti_flags & ACPI_MADT_TRIGGER_MASK) >> 2]); |
90 | if (p->inti_flags & |
91 | ~(ACPI_MADT_POLARITY_MASK | ACPI_MADT_TRIGGER_MASK)) |
92 | pr_info("INT_SRC_OVR unexpected reserved flags: 0x%x\n" , |
93 | p->inti_flags & |
94 | ~(ACPI_MADT_POLARITY_MASK | ACPI_MADT_TRIGGER_MASK)); |
95 | } |
96 | break; |
97 | |
98 | case ACPI_MADT_TYPE_NMI_SOURCE: |
99 | { |
100 | struct acpi_madt_nmi_source *p = |
101 | (struct acpi_madt_nmi_source *)header; |
102 | pr_info("NMI_SRC (%s %s global_irq %d)\n" , |
103 | mps_inti_flags_polarity[p->inti_flags & ACPI_MADT_POLARITY_MASK], |
104 | mps_inti_flags_trigger[(p->inti_flags & ACPI_MADT_TRIGGER_MASK) >> 2], |
105 | p->global_irq); |
106 | } |
107 | break; |
108 | |
109 | case ACPI_MADT_TYPE_LOCAL_APIC_NMI: |
110 | { |
111 | struct acpi_madt_local_apic_nmi *p = |
112 | (struct acpi_madt_local_apic_nmi *)header; |
113 | pr_info("LAPIC_NMI (acpi_id[0x%02x] %s %s lint[0x%x])\n" , |
114 | p->processor_id, |
115 | mps_inti_flags_polarity[p->inti_flags & ACPI_MADT_POLARITY_MASK ], |
116 | mps_inti_flags_trigger[(p->inti_flags & ACPI_MADT_TRIGGER_MASK) >> 2], |
117 | p->lint); |
118 | } |
119 | break; |
120 | |
121 | case ACPI_MADT_TYPE_LOCAL_X2APIC_NMI: |
122 | { |
123 | u16 polarity, trigger; |
124 | struct acpi_madt_local_x2apic_nmi *p = |
125 | (struct acpi_madt_local_x2apic_nmi *)header; |
126 | |
127 | polarity = p->inti_flags & ACPI_MADT_POLARITY_MASK; |
128 | trigger = (p->inti_flags & ACPI_MADT_TRIGGER_MASK) >> 2; |
129 | |
130 | pr_info("X2APIC_NMI (uid[0x%02x] %s %s lint[0x%x])\n" , |
131 | p->uid, |
132 | mps_inti_flags_polarity[polarity], |
133 | mps_inti_flags_trigger[trigger], |
134 | p->lint); |
135 | } |
136 | break; |
137 | |
138 | case ACPI_MADT_TYPE_LOCAL_APIC_OVERRIDE: |
139 | { |
140 | struct acpi_madt_local_apic_override *p = |
141 | (struct acpi_madt_local_apic_override *)header; |
142 | pr_info("LAPIC_ADDR_OVR (address[0x%llx])\n" , |
143 | p->address); |
144 | } |
145 | break; |
146 | |
147 | case ACPI_MADT_TYPE_IO_SAPIC: |
148 | { |
149 | struct acpi_madt_io_sapic *p = |
150 | (struct acpi_madt_io_sapic *)header; |
151 | pr_debug("IOSAPIC (id[0x%x] address[%p] gsi_base[%d])\n" , |
152 | p->id, (void *)(unsigned long)p->address, |
153 | p->global_irq_base); |
154 | } |
155 | break; |
156 | |
157 | case ACPI_MADT_TYPE_LOCAL_SAPIC: |
158 | { |
159 | struct acpi_madt_local_sapic *p = |
160 | (struct acpi_madt_local_sapic *)header; |
161 | pr_debug("LSAPIC (acpi_id[0x%02x] lsapic_id[0x%02x] lsapic_eid[0x%02x] %s)\n" , |
162 | p->processor_id, p->id, p->eid, |
163 | (p->lapic_flags & ACPI_MADT_ENABLED) ? "enabled" : "disabled" ); |
164 | } |
165 | break; |
166 | |
167 | case ACPI_MADT_TYPE_INTERRUPT_SOURCE: |
168 | { |
169 | struct acpi_madt_interrupt_source *p = |
170 | (struct acpi_madt_interrupt_source *)header; |
171 | pr_info("PLAT_INT_SRC (%s %s type[0x%x] id[0x%04x] eid[0x%x] iosapic_vector[0x%x] global_irq[0x%x]\n" , |
172 | mps_inti_flags_polarity[p->inti_flags & ACPI_MADT_POLARITY_MASK], |
173 | mps_inti_flags_trigger[(p->inti_flags & ACPI_MADT_TRIGGER_MASK) >> 2], |
174 | p->type, p->id, p->eid, p->io_sapic_vector, |
175 | p->global_irq); |
176 | } |
177 | break; |
178 | |
179 | case ACPI_MADT_TYPE_GENERIC_INTERRUPT: |
180 | { |
181 | struct acpi_madt_generic_interrupt *p = |
182 | (struct acpi_madt_generic_interrupt *)header; |
183 | pr_debug("GICC (acpi_id[0x%04x] address[%llx] MPIDR[0x%llx] %s)\n" , |
184 | p->uid, p->base_address, |
185 | p->arm_mpidr, |
186 | (p->flags & ACPI_MADT_ENABLED) ? "enabled" : "disabled" ); |
187 | |
188 | } |
189 | break; |
190 | |
191 | case ACPI_MADT_TYPE_GENERIC_DISTRIBUTOR: |
192 | { |
193 | struct acpi_madt_generic_distributor *p = |
194 | (struct acpi_madt_generic_distributor *)header; |
195 | pr_debug("GIC Distributor (gic_id[0x%04x] address[%llx] gsi_base[%d])\n" , |
196 | p->gic_id, p->base_address, |
197 | p->global_irq_base); |
198 | } |
199 | break; |
200 | |
201 | case ACPI_MADT_TYPE_CORE_PIC: |
202 | { |
203 | struct acpi_madt_core_pic *p = (struct acpi_madt_core_pic *)header; |
204 | |
205 | pr_debug("CORE PIC (processor_id[0x%02x] core_id[0x%02x] %s)\n" , |
206 | p->processor_id, p->core_id, |
207 | (p->flags & ACPI_MADT_ENABLED) ? "enabled" : "disabled" ); |
208 | } |
209 | break; |
210 | |
211 | case ACPI_MADT_TYPE_RINTC: |
212 | { |
213 | struct acpi_madt_rintc *p = (struct acpi_madt_rintc *)header; |
214 | |
215 | pr_debug("RISC-V INTC (acpi_uid[0x%04x] hart_id[0x%llx] %s)\n" , |
216 | p->uid, p->hart_id, |
217 | (p->flags & ACPI_MADT_ENABLED) ? "enabled" : "disabled" ); |
218 | } |
219 | break; |
220 | |
221 | default: |
222 | pr_warn("Found unsupported MADT entry (type = 0x%x)\n" , |
223 | header->type); |
224 | break; |
225 | } |
226 | } |
227 | |
228 | int __init_or_acpilib acpi_table_parse_entries_array( |
229 | char *id, unsigned long table_size, struct acpi_subtable_proc *proc, |
230 | int proc_num, unsigned int max_entries) |
231 | { |
232 | struct acpi_table_header * = NULL; |
233 | int count; |
234 | u32 instance = 0; |
235 | |
236 | if (acpi_disabled) |
237 | return -ENODEV; |
238 | |
239 | if (!id) |
240 | return -EINVAL; |
241 | |
242 | if (!table_size) |
243 | return -EINVAL; |
244 | |
245 | if (!strncmp(id, ACPI_SIG_MADT, 4)) |
246 | instance = acpi_apic_instance; |
247 | |
248 | acpi_get_table(signature: id, instance, out_table: &table_header); |
249 | if (!table_header) { |
250 | pr_debug("%4.4s not present\n" , id); |
251 | return -ENODEV; |
252 | } |
253 | |
254 | count = acpi_parse_entries_array(id, table_size, table_header, |
255 | proc, proc_num, max_entries); |
256 | |
257 | acpi_put_table(table: table_header); |
258 | return count; |
259 | } |
260 | |
261 | static int __init_or_acpilib __acpi_table_parse_entries( |
262 | char *id, unsigned long table_size, int entry_id, |
263 | acpi_tbl_entry_handler handler, acpi_tbl_entry_handler_arg handler_arg, |
264 | void *arg, unsigned int max_entries) |
265 | { |
266 | struct acpi_subtable_proc proc = { |
267 | .id = entry_id, |
268 | .handler = handler, |
269 | .handler_arg = handler_arg, |
270 | .arg = arg, |
271 | }; |
272 | |
273 | return acpi_table_parse_entries_array(id, table_size, proc: &proc, proc_num: 1, |
274 | max_entries); |
275 | } |
276 | |
277 | int __init_or_acpilib |
278 | acpi_table_parse_cedt(enum acpi_cedt_type id, |
279 | acpi_tbl_entry_handler_arg handler_arg, void *arg) |
280 | { |
281 | return __acpi_table_parse_entries(ACPI_SIG_CEDT, |
282 | table_size: sizeof(struct acpi_table_cedt), entry_id: id, |
283 | NULL, handler_arg, arg, max_entries: 0); |
284 | } |
285 | EXPORT_SYMBOL_ACPI_LIB(acpi_table_parse_cedt); |
286 | |
287 | int __init acpi_table_parse_entries(char *id, unsigned long table_size, |
288 | int entry_id, |
289 | acpi_tbl_entry_handler handler, |
290 | unsigned int max_entries) |
291 | { |
292 | return __acpi_table_parse_entries(id, table_size, entry_id, handler, |
293 | NULL, NULL, max_entries); |
294 | } |
295 | |
296 | int __init acpi_table_parse_madt(enum acpi_madt_type id, |
297 | acpi_tbl_entry_handler handler, unsigned int max_entries) |
298 | { |
299 | return acpi_table_parse_entries(ACPI_SIG_MADT, |
300 | table_size: sizeof(struct acpi_table_madt), entry_id: id, |
301 | handler, max_entries); |
302 | } |
303 | |
304 | /** |
305 | * acpi_table_parse - find table with @id, run @handler on it |
306 | * @id: table id to find |
307 | * @handler: handler to run |
308 | * |
309 | * Scan the ACPI System Descriptor Table (STD) for a table matching @id, |
310 | * run @handler on it. |
311 | * |
312 | * Return 0 if table found, -errno if not. |
313 | */ |
314 | int __init acpi_table_parse(char *id, acpi_tbl_table_handler handler) |
315 | { |
316 | struct acpi_table_header *table = NULL; |
317 | |
318 | if (acpi_disabled) |
319 | return -ENODEV; |
320 | |
321 | if (!id || !handler) |
322 | return -EINVAL; |
323 | |
324 | if (strncmp(id, ACPI_SIG_MADT, 4) == 0) |
325 | acpi_get_table(signature: id, instance: acpi_apic_instance, out_table: &table); |
326 | else |
327 | acpi_get_table(signature: id, instance: 0, out_table: &table); |
328 | |
329 | if (table) { |
330 | handler(table); |
331 | acpi_put_table(table); |
332 | return 0; |
333 | } else |
334 | return -ENODEV; |
335 | } |
336 | |
337 | /* |
338 | * The BIOS is supposed to supply a single APIC/MADT, |
339 | * but some report two. Provide a knob to use either. |
340 | * (don't you wish instance 0 and 1 were not the same?) |
341 | */ |
342 | static void __init check_multiple_madt(void) |
343 | { |
344 | struct acpi_table_header *table = NULL; |
345 | |
346 | acpi_get_table(ACPI_SIG_MADT, instance: 2, out_table: &table); |
347 | if (table) { |
348 | pr_warn("BIOS bug: multiple APIC/MADT found, using %d\n" , |
349 | acpi_apic_instance); |
350 | pr_warn("If \"acpi_apic_instance=%d\" works better, " |
351 | "notify linux-acpi@vger.kernel.org\n" , |
352 | acpi_apic_instance ? 0 : 2); |
353 | acpi_put_table(table); |
354 | |
355 | } else |
356 | acpi_apic_instance = 0; |
357 | |
358 | return; |
359 | } |
360 | |
361 | static void acpi_table_taint(struct acpi_table_header *table) |
362 | { |
363 | pr_warn("Override [%4.4s-%8.8s], this is unsafe: tainting kernel\n" , |
364 | table->signature, table->oem_table_id); |
365 | add_taint(TAINT_OVERRIDDEN_ACPI_TABLE, LOCKDEP_NOW_UNRELIABLE); |
366 | } |
367 | |
368 | #ifdef CONFIG_ACPI_TABLE_UPGRADE |
369 | static u64 acpi_tables_addr; |
370 | static int all_tables_size; |
371 | |
372 | /* Copied from acpica/tbutils.c:acpi_tb_checksum() */ |
373 | static u8 __init acpi_table_checksum(u8 *buffer, u32 length) |
374 | { |
375 | u8 sum = 0; |
376 | u8 *end = buffer + length; |
377 | |
378 | while (buffer < end) |
379 | sum = (u8) (sum + *(buffer++)); |
380 | return sum; |
381 | } |
382 | |
383 | /* All but ACPI_SIG_RSDP and ACPI_SIG_FACS: */ |
384 | static const char table_sigs[][ACPI_NAMESEG_SIZE] __initconst = { |
385 | ACPI_SIG_BERT, ACPI_SIG_BGRT, ACPI_SIG_CPEP, ACPI_SIG_ECDT, |
386 | ACPI_SIG_EINJ, ACPI_SIG_ERST, ACPI_SIG_HEST, ACPI_SIG_MADT, |
387 | ACPI_SIG_MSCT, ACPI_SIG_SBST, ACPI_SIG_SLIT, ACPI_SIG_SRAT, |
388 | ACPI_SIG_ASF, ACPI_SIG_BOOT, ACPI_SIG_DBGP, ACPI_SIG_DMAR, |
389 | ACPI_SIG_HPET, ACPI_SIG_IBFT, ACPI_SIG_IVRS, ACPI_SIG_MCFG, |
390 | ACPI_SIG_MCHI, ACPI_SIG_SLIC, ACPI_SIG_SPCR, ACPI_SIG_SPMI, |
391 | ACPI_SIG_TCPA, ACPI_SIG_UEFI, ACPI_SIG_WAET, ACPI_SIG_WDAT, |
392 | ACPI_SIG_WDDT, ACPI_SIG_WDRT, ACPI_SIG_DSDT, ACPI_SIG_FADT, |
393 | ACPI_SIG_PSDT, ACPI_SIG_RSDT, ACPI_SIG_XSDT, ACPI_SIG_SSDT, |
394 | ACPI_SIG_IORT, ACPI_SIG_NFIT, ACPI_SIG_HMAT, ACPI_SIG_PPTT, |
395 | ACPI_SIG_NHLT, ACPI_SIG_AEST, ACPI_SIG_CEDT, ACPI_SIG_AGDI, |
396 | ACPI_SIG_NBFT }; |
397 | |
398 | #define sizeof(struct acpi_table_header) |
399 | |
400 | #define NR_ACPI_INITRD_TABLES 64 |
401 | static struct cpio_data __initdata acpi_initrd_files[NR_ACPI_INITRD_TABLES]; |
402 | static DECLARE_BITMAP(acpi_initrd_installed, NR_ACPI_INITRD_TABLES); |
403 | |
404 | #define MAP_CHUNK_SIZE (NR_FIX_BTMAPS << PAGE_SHIFT) |
405 | |
406 | void __init acpi_table_upgrade(void) |
407 | { |
408 | void *data; |
409 | size_t size; |
410 | int sig, no, table_nr = 0, total_offset = 0; |
411 | long offset = 0; |
412 | struct acpi_table_header *table; |
413 | char cpio_path[32] = "kernel/firmware/acpi/" ; |
414 | struct cpio_data file; |
415 | |
416 | if (IS_ENABLED(CONFIG_ACPI_TABLE_OVERRIDE_VIA_BUILTIN_INITRD)) { |
417 | data = __initramfs_start; |
418 | size = __initramfs_size; |
419 | } else { |
420 | data = (void *)initrd_start; |
421 | size = initrd_end - initrd_start; |
422 | } |
423 | |
424 | if (data == NULL || size == 0) |
425 | return; |
426 | |
427 | for (no = 0; no < NR_ACPI_INITRD_TABLES; no++) { |
428 | file = find_cpio_data(path: cpio_path, data, len: size, offset: &offset); |
429 | if (!file.data) |
430 | break; |
431 | |
432 | data += offset; |
433 | size -= offset; |
434 | |
435 | if (file.size < sizeof(struct acpi_table_header)) { |
436 | pr_err("ACPI OVERRIDE: Table smaller than ACPI header [%s%s]\n" , |
437 | cpio_path, file.name); |
438 | continue; |
439 | } |
440 | |
441 | table = file.data; |
442 | |
443 | for (sig = 0; sig < ARRAY_SIZE(table_sigs); sig++) |
444 | if (!memcmp(p: table->signature, q: table_sigs[sig], size: 4)) |
445 | break; |
446 | |
447 | if (sig >= ARRAY_SIZE(table_sigs)) { |
448 | pr_err("ACPI OVERRIDE: Unknown signature [%s%s]\n" , |
449 | cpio_path, file.name); |
450 | continue; |
451 | } |
452 | if (file.size != table->length) { |
453 | pr_err("ACPI OVERRIDE: File length does not match table length [%s%s]\n" , |
454 | cpio_path, file.name); |
455 | continue; |
456 | } |
457 | if (acpi_table_checksum(buffer: file.data, length: table->length)) { |
458 | pr_err("ACPI OVERRIDE: Bad table checksum [%s%s]\n" , |
459 | cpio_path, file.name); |
460 | continue; |
461 | } |
462 | |
463 | pr_info("%4.4s ACPI table found in initrd [%s%s][0x%x]\n" , |
464 | table->signature, cpio_path, file.name, table->length); |
465 | |
466 | all_tables_size += table->length; |
467 | acpi_initrd_files[table_nr].data = file.data; |
468 | acpi_initrd_files[table_nr].size = file.size; |
469 | table_nr++; |
470 | } |
471 | if (table_nr == 0) |
472 | return; |
473 | |
474 | if (security_locked_down(what: LOCKDOWN_ACPI_TABLES)) { |
475 | pr_notice("kernel is locked down, ignoring table override\n" ); |
476 | return; |
477 | } |
478 | |
479 | acpi_tables_addr = |
480 | memblock_phys_alloc_range(size: all_tables_size, PAGE_SIZE, |
481 | start: 0, ACPI_TABLE_UPGRADE_MAX_PHYS); |
482 | if (!acpi_tables_addr) { |
483 | WARN_ON(1); |
484 | return; |
485 | } |
486 | /* |
487 | * Only calling e820_add_reserve does not work and the |
488 | * tables are invalid (memory got used) later. |
489 | * memblock_reserve works as expected and the tables won't get modified. |
490 | * But it's not enough on X86 because ioremap will |
491 | * complain later (used by acpi_os_map_memory) that the pages |
492 | * that should get mapped are not marked "reserved". |
493 | * Both memblock_reserve and e820__range_add (via arch_reserve_mem_area) |
494 | * works fine. |
495 | */ |
496 | arch_reserve_mem_area(addr: acpi_tables_addr, size: all_tables_size); |
497 | |
498 | kmemleak_ignore_phys(phys: acpi_tables_addr); |
499 | |
500 | /* |
501 | * early_ioremap only can remap 256k one time. If we map all |
502 | * tables one time, we will hit the limit. Need to map chunks |
503 | * one by one during copying the same as that in relocate_initrd(). |
504 | */ |
505 | for (no = 0; no < table_nr; no++) { |
506 | unsigned char *src_p = acpi_initrd_files[no].data; |
507 | phys_addr_t size = acpi_initrd_files[no].size; |
508 | phys_addr_t dest_addr = acpi_tables_addr + total_offset; |
509 | phys_addr_t slop, clen; |
510 | char *dest_p; |
511 | |
512 | total_offset += size; |
513 | |
514 | while (size) { |
515 | slop = dest_addr & ~PAGE_MASK; |
516 | clen = size; |
517 | if (clen > MAP_CHUNK_SIZE - slop) |
518 | clen = MAP_CHUNK_SIZE - slop; |
519 | dest_p = early_memremap(phys_addr: dest_addr & PAGE_MASK, |
520 | size: clen + slop); |
521 | memcpy(dest_p + slop, src_p, clen); |
522 | early_memunmap(addr: dest_p, size: clen + slop); |
523 | src_p += clen; |
524 | dest_addr += clen; |
525 | size -= clen; |
526 | } |
527 | } |
528 | } |
529 | |
530 | static acpi_status |
531 | acpi_table_initrd_override(struct acpi_table_header *existing_table, |
532 | acpi_physical_address *address, u32 *length) |
533 | { |
534 | int table_offset = 0; |
535 | int table_index = 0; |
536 | struct acpi_table_header *table; |
537 | u32 table_length; |
538 | |
539 | *length = 0; |
540 | *address = 0; |
541 | if (!acpi_tables_addr) |
542 | return AE_OK; |
543 | |
544 | while (table_offset + ACPI_HEADER_SIZE <= all_tables_size) { |
545 | table = acpi_os_map_memory(where: acpi_tables_addr + table_offset, |
546 | ACPI_HEADER_SIZE); |
547 | if (table_offset + table->length > all_tables_size) { |
548 | acpi_os_unmap_memory(logical_address: table, ACPI_HEADER_SIZE); |
549 | WARN_ON(1); |
550 | return AE_OK; |
551 | } |
552 | |
553 | table_length = table->length; |
554 | |
555 | /* Only override tables matched */ |
556 | if (memcmp(p: existing_table->signature, q: table->signature, size: 4) || |
557 | memcmp(p: table->oem_id, q: existing_table->oem_id, |
558 | ACPI_OEM_ID_SIZE) || |
559 | memcmp(p: table->oem_table_id, q: existing_table->oem_table_id, |
560 | ACPI_OEM_TABLE_ID_SIZE)) { |
561 | acpi_os_unmap_memory(logical_address: table, ACPI_HEADER_SIZE); |
562 | goto next_table; |
563 | } |
564 | /* |
565 | * Mark the table to avoid being used in |
566 | * acpi_table_initrd_scan() and check the revision. |
567 | */ |
568 | if (test_and_set_bit(nr: table_index, addr: acpi_initrd_installed) || |
569 | existing_table->oem_revision >= table->oem_revision) { |
570 | acpi_os_unmap_memory(logical_address: table, ACPI_HEADER_SIZE); |
571 | goto next_table; |
572 | } |
573 | |
574 | *length = table_length; |
575 | *address = acpi_tables_addr + table_offset; |
576 | pr_info("Table Upgrade: override [%4.4s-%6.6s-%8.8s]\n" , |
577 | table->signature, table->oem_id, |
578 | table->oem_table_id); |
579 | acpi_os_unmap_memory(logical_address: table, ACPI_HEADER_SIZE); |
580 | break; |
581 | |
582 | next_table: |
583 | table_offset += table_length; |
584 | table_index++; |
585 | } |
586 | return AE_OK; |
587 | } |
588 | |
589 | static void __init acpi_table_initrd_scan(void) |
590 | { |
591 | int table_offset = 0; |
592 | int table_index = 0; |
593 | u32 table_length; |
594 | struct acpi_table_header *table; |
595 | |
596 | if (!acpi_tables_addr) |
597 | return; |
598 | |
599 | while (table_offset + ACPI_HEADER_SIZE <= all_tables_size) { |
600 | table = acpi_os_map_memory(where: acpi_tables_addr + table_offset, |
601 | ACPI_HEADER_SIZE); |
602 | if (table_offset + table->length > all_tables_size) { |
603 | acpi_os_unmap_memory(logical_address: table, ACPI_HEADER_SIZE); |
604 | WARN_ON(1); |
605 | return; |
606 | } |
607 | |
608 | table_length = table->length; |
609 | |
610 | /* Skip RSDT/XSDT which should only be used for override */ |
611 | if (ACPI_COMPARE_NAMESEG(table->signature, ACPI_SIG_RSDT) || |
612 | ACPI_COMPARE_NAMESEG(table->signature, ACPI_SIG_XSDT)) { |
613 | acpi_os_unmap_memory(logical_address: table, ACPI_HEADER_SIZE); |
614 | goto next_table; |
615 | } |
616 | /* |
617 | * Mark the table to avoid being used in |
618 | * acpi_table_initrd_override(). Though this is not possible |
619 | * because override is disabled in acpi_install_physical_table(). |
620 | */ |
621 | if (test_and_set_bit(nr: table_index, addr: acpi_initrd_installed)) { |
622 | acpi_os_unmap_memory(logical_address: table, ACPI_HEADER_SIZE); |
623 | goto next_table; |
624 | } |
625 | |
626 | pr_info("Table Upgrade: install [%4.4s-%6.6s-%8.8s]\n" , |
627 | table->signature, table->oem_id, |
628 | table->oem_table_id); |
629 | acpi_os_unmap_memory(logical_address: table, ACPI_HEADER_SIZE); |
630 | acpi_install_physical_table(address: acpi_tables_addr + table_offset); |
631 | next_table: |
632 | table_offset += table_length; |
633 | table_index++; |
634 | } |
635 | } |
636 | #else |
637 | static acpi_status |
638 | acpi_table_initrd_override(struct acpi_table_header *existing_table, |
639 | acpi_physical_address *address, |
640 | u32 *table_length) |
641 | { |
642 | *table_length = 0; |
643 | *address = 0; |
644 | return AE_OK; |
645 | } |
646 | |
647 | static void __init acpi_table_initrd_scan(void) |
648 | { |
649 | } |
650 | #endif /* CONFIG_ACPI_TABLE_UPGRADE */ |
651 | |
652 | acpi_status |
653 | acpi_os_physical_table_override(struct acpi_table_header *existing_table, |
654 | acpi_physical_address *address, |
655 | u32 *table_length) |
656 | { |
657 | return acpi_table_initrd_override(existing_table, address, |
658 | length: table_length); |
659 | } |
660 | |
661 | #ifdef CONFIG_ACPI_CUSTOM_DSDT |
662 | static void *amlcode __attribute__ ((weakref("AmlCode" ))); |
663 | static void *dsdt_amlcode __attribute__ ((weakref("dsdt_aml_code" ))); |
664 | #endif |
665 | |
666 | acpi_status acpi_os_table_override(struct acpi_table_header *existing_table, |
667 | struct acpi_table_header **new_table) |
668 | { |
669 | if (!existing_table || !new_table) |
670 | return AE_BAD_PARAMETER; |
671 | |
672 | *new_table = NULL; |
673 | |
674 | #ifdef CONFIG_ACPI_CUSTOM_DSDT |
675 | if (!strncmp(existing_table->signature, "DSDT" , 4)) { |
676 | *new_table = (struct acpi_table_header *)&amlcode; |
677 | if (!(*new_table)) |
678 | *new_table = (struct acpi_table_header *)&dsdt_amlcode; |
679 | } |
680 | #endif |
681 | if (*new_table != NULL) |
682 | acpi_table_taint(table: existing_table); |
683 | return AE_OK; |
684 | } |
685 | |
686 | /* |
687 | * acpi_locate_initial_tables() |
688 | * |
689 | * Get the RSDP, then find and checksum all the ACPI tables. |
690 | * |
691 | * result: initial_tables[] is initialized, and points to |
692 | * a list of ACPI tables. |
693 | */ |
694 | int __init acpi_locate_initial_tables(void) |
695 | { |
696 | acpi_status status; |
697 | |
698 | if (acpi_verify_table_checksum) { |
699 | pr_info("Early table checksum verification enabled\n" ); |
700 | acpi_gbl_enable_table_validation = TRUE; |
701 | } else { |
702 | pr_info("Early table checksum verification disabled\n" ); |
703 | acpi_gbl_enable_table_validation = FALSE; |
704 | } |
705 | |
706 | status = acpi_initialize_tables(initial_storage: initial_tables, ACPI_MAX_TABLES, allow_resize: 0); |
707 | if (ACPI_FAILURE(status)) |
708 | return -EINVAL; |
709 | |
710 | return 0; |
711 | } |
712 | |
713 | void __init acpi_reserve_initial_tables(void) |
714 | { |
715 | int i; |
716 | |
717 | for (i = 0; i < ACPI_MAX_TABLES; i++) { |
718 | struct acpi_table_desc *table_desc = &initial_tables[i]; |
719 | u64 start = table_desc->address; |
720 | u64 size = table_desc->length; |
721 | |
722 | if (!start || !size) |
723 | break; |
724 | |
725 | pr_info("Reserving %4s table memory at [mem 0x%llx-0x%llx]\n" , |
726 | table_desc->signature.ascii, start, start + size - 1); |
727 | |
728 | memblock_reserve(base: start, size); |
729 | } |
730 | } |
731 | |
732 | void __init acpi_table_init_complete(void) |
733 | { |
734 | acpi_table_initrd_scan(); |
735 | check_multiple_madt(); |
736 | } |
737 | |
738 | int __init acpi_table_init(void) |
739 | { |
740 | int ret; |
741 | |
742 | ret = acpi_locate_initial_tables(); |
743 | if (ret) |
744 | return ret; |
745 | |
746 | acpi_table_init_complete(); |
747 | |
748 | return 0; |
749 | } |
750 | |
751 | static int __init acpi_parse_apic_instance(char *str) |
752 | { |
753 | if (!str) |
754 | return -EINVAL; |
755 | |
756 | if (kstrtoint(s: str, base: 0, res: &acpi_apic_instance)) |
757 | return -EINVAL; |
758 | |
759 | pr_notice("Shall use APIC/MADT table %d\n" , acpi_apic_instance); |
760 | |
761 | return 0; |
762 | } |
763 | early_param("acpi_apic_instance" , acpi_parse_apic_instance); |
764 | |
765 | static int __init acpi_force_table_verification_setup(char *s) |
766 | { |
767 | acpi_verify_table_checksum = true; |
768 | |
769 | return 0; |
770 | } |
771 | early_param("acpi_force_table_verification" , acpi_force_table_verification_setup); |
772 | |
773 | static int __init acpi_force_32bit_fadt_addr(char *s) |
774 | { |
775 | pr_info("Forcing 32 Bit FADT addresses\n" ); |
776 | acpi_gbl_use32_bit_fadt_addresses = TRUE; |
777 | |
778 | return 0; |
779 | } |
780 | early_param("acpi_force_32bit_fadt_addr" , acpi_force_32bit_fadt_addr); |
781 | |