[deliverable/linux.git] / drivers / acpi / processor_core.c

/*
 * Copyright (C) 2005 Intel Corporation
 * Copyright (C) 2009 Hewlett-Packard Development Company, L.P.
 *
 *	Alex Chiang <achiang@hp.com>
 *	- Unified x86/ia64 implementations
 *
 * I/O APIC hotplug support
 *	Yinghai Lu <yinghai@kernel.org>
 *	Jiang Liu <jiang.liu@intel.com>
 */
#include <linux/export.h>
#include <linux/acpi.h>
#include <acpi/processor.h>

#define _COMPONENT		ACPI_PROCESSOR_COMPONENT
ACPI_MODULE_NAME("processor_core");

static struct acpi_table_madt *get_madt_table(void)
{
	static struct acpi_table_madt *madt;
	static int read_madt;

	if (!read_madt) {
		if (ACPI_FAILURE(acpi_get_table(ACPI_SIG_MADT, 0,
					(struct acpi_table_header **)&madt)))
			madt = NULL;
		read_madt++;
	}

	return madt;
}

static int map_lapic_id(struct acpi_subtable_header *entry,
		 u32 acpi_id, phys_cpuid_t *apic_id)
{
	struct acpi_madt_local_apic *lapic =
		container_of(entry, struct acpi_madt_local_apic, header);

	if (!(lapic->lapic_flags & ACPI_MADT_ENABLED))
		return -ENODEV;

	if (lapic->processor_id != acpi_id)
		return -EINVAL;

	*apic_id = lapic->id;
	return 0;
}

static int map_x2apic_id(struct acpi_subtable_header *entry,
		int device_declaration, u32 acpi_id, phys_cpuid_t *apic_id)
{
	struct acpi_madt_local_x2apic *apic =
		container_of(entry, struct acpi_madt_local_x2apic, header);

	if (!(apic->lapic_flags & ACPI_MADT_ENABLED))
		return -ENODEV;

	if (device_declaration && (apic->uid == acpi_id)) {
		*apic_id = apic->local_apic_id;
		return 0;
	}

	return -EINVAL;
}

static int map_lsapic_id(struct acpi_subtable_header *entry,
		int device_declaration, u32 acpi_id, phys_cpuid_t *apic_id)
{
	struct acpi_madt_local_sapic *lsapic =
		container_of(entry, struct acpi_madt_local_sapic, header);

	if (!(lsapic->lapic_flags & ACPI_MADT_ENABLED))
		return -ENODEV;

	if (device_declaration) {
		if ((entry->length < 16) || (lsapic->uid != acpi_id))
			return -EINVAL;
	} else if (lsapic->processor_id != acpi_id)
		return -EINVAL;

	*apic_id = (lsapic->id << 8) | lsapic->eid;
	return 0;
}

/*
 * Retrieve the ARM CPU physical identifier (MPIDR)
 */
static int map_gicc_mpidr(struct acpi_subtable_header *entry,
		int device_declaration, u32 acpi_id, phys_cpuid_t *mpidr)
{
	struct acpi_madt_generic_interrupt *gicc =
	    container_of(entry, struct acpi_madt_generic_interrupt, header);

	if (!(gicc->flags & ACPI_MADT_ENABLED))
		return -ENODEV;

	/* device_declaration means Device object in DSDT, in the
	 * GIC interrupt model, logical processors are required to
	 * have a Processor Device object in the DSDT, so we should
	 * check device_declaration here
	 */
	if (device_declaration && (gicc->uid == acpi_id)) {
		*mpidr = gicc->arm_mpidr;
		return 0;
	}

	return -EINVAL;
}

static phys_cpuid_t map_madt_entry(int type, u32 acpi_id)
{
	unsigned long madt_end, entry;
	phys_cpuid_t phys_id = PHYS_CPUID_INVALID;	/* CPU hardware ID */
	struct acpi_table_madt *madt;

	madt = get_madt_table();
	if (!madt)
		return phys_id;

	entry = (unsigned long)madt;
	madt_end = entry + madt->header.length;

	/* Parse all entries looking for a match. */

	entry += sizeof(struct acpi_table_madt);
	while (entry + sizeof(struct acpi_subtable_header) < madt_end) {
		struct acpi_subtable_header *header =
			(struct acpi_subtable_header *)entry;
		if (header->type == ACPI_MADT_TYPE_LOCAL_APIC) {
			if (!map_lapic_id(header, acpi_id, &phys_id))
				break;
		} else if (header->type == ACPI_MADT_TYPE_LOCAL_X2APIC) {
			if (!map_x2apic_id(header, type, acpi_id, &phys_id))
				break;
		} else if (header->type == ACPI_MADT_TYPE_LOCAL_SAPIC) {
			if (!map_lsapic_id(header, type, acpi_id, &phys_id))
				break;
		} else if (header->type == ACPI_MADT_TYPE_GENERIC_INTERRUPT) {
			if (!map_gicc_mpidr(header, type, acpi_id, &phys_id))
				break;
		}
		entry += header->length;
	}
	return phys_id;
}

static phys_cpuid_t map_mat_entry(acpi_handle handle, int type, u32 acpi_id)
{
	struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
	union acpi_object *obj;
	struct acpi_subtable_header *header;
	phys_cpuid_t phys_id = PHYS_CPUID_INVALID;

	if (ACPI_FAILURE(acpi_evaluate_object(handle, "_MAT", NULL, &buffer)))
		goto exit;

	if (!buffer.length || !buffer.pointer)
		goto exit;

	obj = buffer.pointer;
	if (obj->type != ACPI_TYPE_BUFFER ||
	    obj->buffer.length < sizeof(struct acpi_subtable_header)) {
		goto exit;
	}

	header = (struct acpi_subtable_header *)obj->buffer.pointer;
	if (header->type == ACPI_MADT_TYPE_LOCAL_APIC)
		map_lapic_id(header, acpi_id, &phys_id);
	else if (header->type == ACPI_MADT_TYPE_LOCAL_SAPIC)
		map_lsapic_id(header, type, acpi_id, &phys_id);
	else if (header->type == ACPI_MADT_TYPE_LOCAL_X2APIC)
		map_x2apic_id(header, type, acpi_id, &phys_id);
	else if (header->type == ACPI_MADT_TYPE_GENERIC_INTERRUPT)
		map_gicc_mpidr(header, type, acpi_id, &phys_id);

exit:
	kfree(buffer.pointer);
	return phys_id;
}

phys_cpuid_t acpi_get_phys_id(acpi_handle handle, int type, u32 acpi_id)
{
	phys_cpuid_t phys_id;

	phys_id = map_mat_entry(handle, type, acpi_id);
	if (invalid_phys_cpuid(phys_id))
		phys_id = map_madt_entry(type, acpi_id);

	return phys_id;
}

int acpi_map_cpuid(phys_cpuid_t phys_id, u32 acpi_id)
{
#ifdef CONFIG_SMP
	int i;
#endif

	if (invalid_phys_cpuid(phys_id)) {
		/*
		 * On UP processor, there is no _MAT or MADT table.
		 * So above phys_id is always set to PHYS_CPUID_INVALID.
		 *
		 * BIOS may define multiple CPU handles even for UP processor.
		 * For example,
		 *
		 * Scope (_PR)
		 * {
		 *     Processor (CPU0, 0x00, 0x00000410, 0x06) {}
		 *     Processor (CPU1, 0x01, 0x00000410, 0x06) {}
		 *     Processor (CPU2, 0x02, 0x00000410, 0x06) {}
		 *     Processor (CPU3, 0x03, 0x00000410, 0x06) {}
		 * }
		 *
		 * Ignores phys_id and always returns 0 for the processor
		 * handle with acpi id 0 if nr_cpu_ids is 1.
		 * This should be the case if SMP tables are not found.
		 * Return -EINVAL for other CPU's handle.
		 */
		if (nr_cpu_ids <= 1 && acpi_id == 0)
			return acpi_id;
		else
			return -EINVAL;
	}

#ifdef CONFIG_SMP
	for_each_possible_cpu(i) {
		if (cpu_physical_id(i) == phys_id)
			return i;
	}
#else
	/* In UP kernel, only processor 0 is valid */
	if (phys_id == 0)
		return phys_id;
#endif
	return -ENODEV;
}

int acpi_get_cpuid(acpi_handle handle, int type, u32 acpi_id)
{
	phys_cpuid_t phys_id;

	phys_id = acpi_get_phys_id(handle, type, acpi_id);

	return acpi_map_cpuid(phys_id, acpi_id);
}
EXPORT_SYMBOL_GPL(acpi_get_cpuid);

#ifdef CONFIG_ACPI_HOTPLUG_IOAPIC
static int get_ioapic_id(struct acpi_subtable_header *entry, u32 gsi_base,
			 u64 *phys_addr, int *ioapic_id)
{
	struct acpi_madt_io_apic *ioapic = (struct acpi_madt_io_apic *)entry;

	if (ioapic->global_irq_base != gsi_base)
		return 0;

	*phys_addr = ioapic->address;
	*ioapic_id = ioapic->id;
	return 1;
}

static int parse_madt_ioapic_entry(u32 gsi_base, u64 *phys_addr)
{
	struct acpi_subtable_header *hdr;
	unsigned long madt_end, entry;
	struct acpi_table_madt *madt;
	int apic_id = -1;

	madt = get_madt_table();
	if (!madt)
		return apic_id;

	entry = (unsigned long)madt;
	madt_end = entry + madt->header.length;

	/* Parse all entries looking for a match. */
	entry += sizeof(struct acpi_table_madt);
	while (entry + sizeof(struct acpi_subtable_header) < madt_end) {
		hdr = (struct acpi_subtable_header *)entry;
		if (hdr->type == ACPI_MADT_TYPE_IO_APIC &&
		    get_ioapic_id(hdr, gsi_base, phys_addr, &apic_id))
			break;
		else
			entry += hdr->length;
	}

	return apic_id;
}

static int parse_mat_ioapic_entry(acpi_handle handle, u32 gsi_base,
				  u64 *phys_addr)
{
	struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
	struct acpi_subtable_header *header;
	union acpi_object *obj;
	int apic_id = -1;

	if (ACPI_FAILURE(acpi_evaluate_object(handle, "_MAT", NULL, &buffer)))
		goto exit;

	if (!buffer.length || !buffer.pointer)
		goto exit;

	obj = buffer.pointer;
	if (obj->type != ACPI_TYPE_BUFFER ||
	    obj->buffer.length < sizeof(struct acpi_subtable_header))
		goto exit;

	header = (struct acpi_subtable_header *)obj->buffer.pointer;
	if (header->type == ACPI_MADT_TYPE_IO_APIC)
		get_ioapic_id(header, gsi_base, phys_addr, &apic_id);

exit:
	kfree(buffer.pointer);
	return apic_id;
}

/**
 * acpi_get_ioapic_id - Get IOAPIC ID and physical address matching @gsi_base
 * @handle:	ACPI object for IOAPIC device
 * @gsi_base:	GSI base to match with
 * @phys_addr:	Pointer to store physical address of matching IOAPIC record
 *
 * Walk resources returned by ACPI_MAT method, then ACPI MADT table, to search
 * for an ACPI IOAPIC record matching @gsi_base.
 * Return IOAPIC id and store physical address in @phys_addr if found a match,
 * otherwise return <0.
 */
int acpi_get_ioapic_id(acpi_handle handle, u32 gsi_base, u64 *phys_addr)
{
	int apic_id;

	apic_id = parse_mat_ioapic_entry(handle, gsi_base, phys_addr);
	if (apic_id == -1)
		apic_id = parse_madt_ioapic_entry(gsi_base, phys_addr);

	return apic_id;
}
#endif /* CONFIG_ACPI_HOTPLUG_IOAPIC */
Commit	Line	Data
47817254 AC	1	/*
	2	* Copyright (C) 2005 Intel Corporation
	3	* Copyright (C) 2009 Hewlett-Packard Development Company, L.P.
	4	*
	5	* Alex Chiang <achiang@hp.com>
	6	* - Unified x86/ia64 implementations
ecf5636d YL	7	*
	8	* I/O APIC hotplug support
	9	* Yinghai Lu <yinghai@kernel.org>
	10	* Jiang Liu <jiang.liu@intel.com>
47817254	11	*/
214f2c90	12	#include <linux/export.h>
8b48463f	13	#include <linux/acpi.h>
78f16996 AC	14	#include <acpi/processor.h>
78f16996 AC	15
78f16996	16	#define _COMPONENT ACPI_PROCESSOR_COMPONENT
4d5d4cd8	17	ACPI_MODULE_NAME("processor_core");
78f16996	18
ecf5636d YL	19	static struct acpi_table_madt *get_madt_table(void)
	20	{
	21	static struct acpi_table_madt *madt;
	22	static int read_madt;
	23
	24	if (!read_madt) {
	25	if (ACPI_FAILURE(acpi_get_table(ACPI_SIG_MADT, 0,
	26	(struct acpi_table_header **)&madt)))
	27	madt = NULL;
	28	read_madt++;
	29	}
	30
	31	return madt;
	32	}
	33
78ed8bd2	34	static int map_lapic_id(struct acpi_subtable_header *entry,
828aef37	35	u32 acpi_id, phys_cpuid_t *apic_id)
78ed8bd2 AC	36	{
78ed8bd2 AC	37	struct acpi_madt_local_apic *lapic =
ef86c3f4	38	container_of(entry, struct acpi_madt_local_apic, header);
11130736 AC	39
11130736 AC	40	if (!(lapic->lapic_flags & ACPI_MADT_ENABLED))
038d7b59	41	return -ENODEV;
11130736 AC	42
11130736 AC	43	if (lapic->processor_id != acpi_id)
038d7b59	44	return -EINVAL;
11130736 AC	45
11130736 AC	46	*apic_id = lapic->id;
038d7b59	47	return 0;
78ed8bd2 AC	48	}
	49
	50	static int map_x2apic_id(struct acpi_subtable_header *entry,
828aef37	51	int device_declaration, u32 acpi_id, phys_cpuid_t *apic_id)
78ed8bd2 AC	52	{
78ed8bd2 AC	53	struct acpi_madt_local_x2apic *apic =
ef86c3f4	54	container_of(entry, struct acpi_madt_local_x2apic, header);
78ed8bd2	55
78ed8bd2	56	if (!(apic->lapic_flags & ACPI_MADT_ENABLED))
038d7b59	57	return -ENODEV;
78ed8bd2	58
d6742095 AC	59	if (device_declaration && (apic->uid == acpi_id)) {
d6742095 AC	60	*apic_id = apic->local_apic_id;
038d7b59	61	return 0;
78ed8bd2 AC	62	}
78ed8bd2 AC	63
038d7b59	64	return -EINVAL;
78ed8bd2 AC	65	}
	66
	67	static int map_lsapic_id(struct acpi_subtable_header *entry,
828aef37	68	int device_declaration, u32 acpi_id, phys_cpuid_t *apic_id)
78ed8bd2 AC	69	{
78ed8bd2 AC	70	struct acpi_madt_local_sapic *lsapic =
ef86c3f4	71	container_of(entry, struct acpi_madt_local_sapic, header);
78ed8bd2	72
78ed8bd2	73	if (!(lsapic->lapic_flags & ACPI_MADT_ENABLED))
038d7b59	74	return -ENODEV;
78ed8bd2	75
78ed8bd2	76	if (device_declaration) {
eae701ce	77	if ((entry->length < 16) \|\| (lsapic->uid != acpi_id))
038d7b59	78	return -EINVAL;
eae701ce	79	} else if (lsapic->processor_id != acpi_id)
038d7b59	80	return -EINVAL;
78ed8bd2	81
eae701ce	82	*apic_id = (lsapic->id << 8) \| lsapic->eid;
038d7b59	83	return 0;
78ed8bd2 AC	84	}
78ed8bd2 AC	85
020295b4 HG	86	/*
	87	* Retrieve the ARM CPU physical identifier (MPIDR)
	88	*/
	89	static int map_gicc_mpidr(struct acpi_subtable_header *entry,
	90	int device_declaration, u32 acpi_id, phys_cpuid_t *mpidr)
	91	{
	92	struct acpi_madt_generic_interrupt *gicc =
	93	container_of(entry, struct acpi_madt_generic_interrupt, header);
	94
	95	if (!(gicc->flags & ACPI_MADT_ENABLED))
	96	return -ENODEV;
	97
	98	/* device_declaration means Device object in DSDT, in the
	99	* GIC interrupt model, logical processors are required to
	100	* have a Processor Device object in the DSDT, so we should
	101	* check device_declaration here
	102	*/
	103	if (device_declaration && (gicc->uid == acpi_id)) {
	104	*mpidr = gicc->arm_mpidr;
	105	return 0;
	106	}
	107
	108	return -EINVAL;
	109	}
	110
828aef37	111	static phys_cpuid_t map_madt_entry(int type, u32 acpi_id)
78ed8bd2 AC	112	{
78ed8bd2 AC	113	unsigned long madt_end, entry;
828aef37	114	phys_cpuid_t phys_id = PHYS_CPUID_INVALID; /* CPU hardware ID */
ecf5636d	115	struct acpi_table_madt *madt;
78ed8bd2	116
ecf5636d	117	madt = get_madt_table();
78ed8bd2	118	if (!madt)
af8f3f51	119	return phys_id;
78ed8bd2 AC	120
	121	entry = (unsigned long)madt;
	122	madt_end = entry + madt->header.length;
	123
	124	/* Parse all entries looking for a match. */
	125
	126	entry += sizeof(struct acpi_table_madt);
	127	while (entry + sizeof(struct acpi_subtable_header) < madt_end) {
	128	struct acpi_subtable_header *header =
	129	(struct acpi_subtable_header *)entry;
	130	if (header->type == ACPI_MADT_TYPE_LOCAL_APIC) {
af8f3f51	131	if (!map_lapic_id(header, acpi_id, &phys_id))
78ed8bd2 AC	132	break;
78ed8bd2 AC	133	} else if (header->type == ACPI_MADT_TYPE_LOCAL_X2APIC) {
af8f3f51	134	if (!map_x2apic_id(header, type, acpi_id, &phys_id))
78ed8bd2 AC	135	break;
78ed8bd2 AC	136	} else if (header->type == ACPI_MADT_TYPE_LOCAL_SAPIC) {
af8f3f51	137	if (!map_lsapic_id(header, type, acpi_id, &phys_id))
78ed8bd2	138	break;
020295b4 HG	139	} else if (header->type == ACPI_MADT_TYPE_GENERIC_INTERRUPT) {
	140	if (!map_gicc_mpidr(header, type, acpi_id, &phys_id))
	141	break;
78ed8bd2 AC	142	}
	143	entry += header->length;
	144	}
af8f3f51	145	return phys_id;
78ed8bd2 AC	146	}
78ed8bd2 AC	147
828aef37	148	static phys_cpuid_t map_mat_entry(acpi_handle handle, int type, u32 acpi_id)
78ed8bd2 AC	149	{
	150	struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
	151	union acpi_object *obj;
	152	struct acpi_subtable_header *header;
828aef37	153	phys_cpuid_t phys_id = PHYS_CPUID_INVALID;
78ed8bd2 AC	154
	155	if (ACPI_FAILURE(acpi_evaluate_object(handle, "_MAT", NULL, &buffer)))
	156	goto exit;
	157
	158	if (!buffer.length \|\| !buffer.pointer)
	159	goto exit;
	160
	161	obj = buffer.pointer;
	162	if (obj->type != ACPI_TYPE_BUFFER \|\|
	163	obj->buffer.length < sizeof(struct acpi_subtable_header)) {
	164	goto exit;
	165	}
	166
	167	header = (struct acpi_subtable_header *)obj->buffer.pointer;
13ca62b2	168	if (header->type == ACPI_MADT_TYPE_LOCAL_APIC)
af8f3f51	169	map_lapic_id(header, acpi_id, &phys_id);
13ca62b2	170	else if (header->type == ACPI_MADT_TYPE_LOCAL_SAPIC)
af8f3f51	171	map_lsapic_id(header, type, acpi_id, &phys_id);
13ca62b2	172	else if (header->type == ACPI_MADT_TYPE_LOCAL_X2APIC)
af8f3f51	173	map_x2apic_id(header, type, acpi_id, &phys_id);
020295b4 HG	174	else if (header->type == ACPI_MADT_TYPE_GENERIC_INTERRUPT)
020295b4 HG	175	map_gicc_mpidr(header, type, acpi_id, &phys_id);
78ed8bd2 AC	176
78ed8bd2 AC	177	exit:
5273a258	178	kfree(buffer.pointer);
af8f3f51	179	return phys_id;
78ed8bd2 AC	180	}
78ed8bd2 AC	181
828aef37	182	phys_cpuid_t acpi_get_phys_id(acpi_handle handle, int type, u32 acpi_id)
78ed8bd2	183	{
828aef37	184	phys_cpuid_t phys_id;
78ed8bd2	185
af8f3f51	186	phys_id = map_mat_entry(handle, type, acpi_id);
ddcc18f5	187	if (invalid_phys_cpuid(phys_id))
af8f3f51	188	phys_id = map_madt_entry(type, acpi_id);
ca9f62ac	189
af8f3f51	190	return phys_id;
ca9f62ac JL	191	}
ca9f62ac JL	192
828aef37	193	int acpi_map_cpuid(phys_cpuid_t phys_id, u32 acpi_id)
ca9f62ac JL	194	{
	195	#ifdef CONFIG_SMP
	196	int i;
	197	#endif
	198
ddcc18f5	199	if (invalid_phys_cpuid(phys_id)) {
d640113f LM	200	/*
d640113f LM	201	* On UP processor, there is no _MAT or MADT table.
828aef37	202	* So above phys_id is always set to PHYS_CPUID_INVALID.
d640113f LM	203	*
	204	* BIOS may define multiple CPU handles even for UP processor.
	205	* For example,
	206	*
	207	* Scope (_PR)
13ca62b2	208	* {
d640113f LM	209	* Processor (CPU0, 0x00, 0x00000410, 0x06) {}
	210	* Processor (CPU1, 0x01, 0x00000410, 0x06) {}
	211	* Processor (CPU2, 0x02, 0x00000410, 0x06) {}
	212	* Processor (CPU3, 0x03, 0x00000410, 0x06) {}
	213	* }
	214	*
af8f3f51	215	* Ignores phys_id and always returns 0 for the processor
c4686c71 TR	216	* handle with acpi id 0 if nr_cpu_ids is 1.
c4686c71 TR	217	* This should be the case if SMP tables are not found.
d3da7cb9	218	* Return -EINVAL for other CPU's handle.
d640113f	219	*/
c4686c71	220	if (nr_cpu_ids <= 1 && acpi_id == 0)
d640113f LM	221	return acpi_id;
d640113f LM	222	else
d3da7cb9	223	return -EINVAL;
d640113f	224	}
78ed8bd2	225
932df741	226	#ifdef CONFIG_SMP
78ed8bd2	227	for_each_possible_cpu(i) {
af8f3f51	228	if (cpu_physical_id(i) == phys_id)
78ed8bd2 AC	229	return i;
78ed8bd2 AC	230	}
932df741 LM	231	#else
932df741 LM	232	/* In UP kernel, only processor 0 is valid */
af8f3f51 HG	233	if (phys_id == 0)
af8f3f51 HG	234	return phys_id;
932df741	235	#endif
d3da7cb9	236	return -ENODEV;
78ed8bd2	237	}
ca9f62ac JL	238
	239	int acpi_get_cpuid(acpi_handle handle, int type, u32 acpi_id)
	240	{
828aef37	241	phys_cpuid_t phys_id;
ca9f62ac	242
af8f3f51	243	phys_id = acpi_get_phys_id(handle, type, acpi_id);
ca9f62ac	244
af8f3f51	245	return acpi_map_cpuid(phys_id, acpi_id);
ca9f62ac	246	}
78ed8bd2	247	EXPORT_SYMBOL_GPL(acpi_get_cpuid);
ecf5636d YL	248
	249	#ifdef CONFIG_ACPI_HOTPLUG_IOAPIC
	250	static int get_ioapic_id(struct acpi_subtable_header *entry, u32 gsi_base,
	251	u64 phys_addr, int ioapic_id)
	252	{
	253	struct acpi_madt_io_apic ioapic = (struct acpi_madt_io_apic )entry;
	254
	255	if (ioapic->global_irq_base != gsi_base)
	256	return 0;
	257
	258	*phys_addr = ioapic->address;
	259	*ioapic_id = ioapic->id;
	260	return 1;
	261	}
	262
	263	static int parse_madt_ioapic_entry(u32 gsi_base, u64 *phys_addr)
	264	{
	265	struct acpi_subtable_header *hdr;
	266	unsigned long madt_end, entry;
	267	struct acpi_table_madt *madt;
	268	int apic_id = -1;
	269
	270	madt = get_madt_table();
	271	if (!madt)
	272	return apic_id;
	273
	274	entry = (unsigned long)madt;
	275	madt_end = entry + madt->header.length;
	276
	277	/* Parse all entries looking for a match. */
	278	entry += sizeof(struct acpi_table_madt);
	279	while (entry + sizeof(struct acpi_subtable_header) < madt_end) {
	280	hdr = (struct acpi_subtable_header *)entry;
	281	if (hdr->type == ACPI_MADT_TYPE_IO_APIC &&
	282	get_ioapic_id(hdr, gsi_base, phys_addr, &apic_id))
	283	break;
	284	else
	285	entry += hdr->length;
	286	}
	287
	288	return apic_id;
	289	}
	290
	291	static int parse_mat_ioapic_entry(acpi_handle handle, u32 gsi_base,
	292	u64 *phys_addr)
	293	{
	294	struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
	295	struct acpi_subtable_header *header;
	296	union acpi_object *obj;
	297	int apic_id = -1;
	298
	299	if (ACPI_FAILURE(acpi_evaluate_object(handle, "_MAT", NULL, &buffer)))
	300	goto exit;
	301
	302	if (!buffer.length \|\| !buffer.pointer)
	303	goto exit;
	304
	305	obj = buffer.pointer;
	306	if (obj->type != ACPI_TYPE_BUFFER \|\|
	307	obj->buffer.length < sizeof(struct acpi_subtable_header))
	308	goto exit;
	309
	310	header = (struct acpi_subtable_header *)obj->buffer.pointer;
	311	if (header->type == ACPI_MADT_TYPE_IO_APIC)
312	get_ioapic_id(header, gsi_base, phys_addr, &apic_id);
313
314	exit:
315	kfree(buffer.pointer);
316	return apic_id;
317	}
318
319	/**
320	* acpi_get_ioapic_id - Get IOAPIC ID and physical address matching @gsi_base
321	* @handle: ACPI object for IOAPIC device
322	* @gsi_base: GSI base to match with
323	* @phys_addr: Pointer to store physical address of matching IOAPIC record
324	*
325	* Walk resources returned by ACPI_MAT method, then ACPI MADT table, to search
326	* for an ACPI IOAPIC record matching @gsi_base.
327	* Return IOAPIC id and store physical address in @phys_addr if found a match,
328	* otherwise return <0.
329	*/
330	int acpi_get_ioapic_id(acpi_handle handle, u32 gsi_base, u64 *phys_addr)
331	{
332	int apic_id;
333
334	apic_id = parse_mat_ioapic_entry(handle, gsi_base, phys_addr);
335	if (apic_id == -1)
336	apic_id = parse_madt_ioapic_entry(gsi_base, phys_addr);
337
338	return apic_id;
339	}
340	#endif /* CONFIG_ACPI_HOTPLUG_IOAPIC */