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