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