[linux-2.6-block.git] / drivers / acpi / processor_core.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * 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>

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 (!acpi_gicc_is_usable(gicc))
		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;
}

/*
 * Retrieve the RISC-V hartid for the processor
 */
static int map_rintc_hartid(struct acpi_subtable_header *entry,
			    int device_declaration, u32 acpi_id,
			    phys_cpuid_t *hartid)
{
	struct acpi_madt_rintc *rintc =
	    container_of(entry, struct acpi_madt_rintc, header);

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

	/* device_declaration means Device object in DSDT, in the
	 * RISC-V, logical processors are required to
	 * have a Processor Device object in the DSDT, so we should
	 * check device_declaration here
	 */
	if (device_declaration && rintc->uid == acpi_id) {
		*hartid = rintc->hart_id;
		return 0;
	}

	return -EINVAL;
}

/*
 * Retrieve LoongArch CPU physical id
 */
static int map_core_pic_id(struct acpi_subtable_header *entry,
		int device_declaration, u32 acpi_id, phys_cpuid_t *phys_id)
{
	struct acpi_madt_core_pic *core_pic =
		container_of(entry, struct acpi_madt_core_pic, header);

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

	/* device_declaration means Device object in DSDT, in LoongArch
	 * system, logical processor acpi_id is required in _UID property
	 * of DSDT table, so we should check device_declaration here
	 */
	if (device_declaration && (core_pic->processor_id == acpi_id)) {
		*phys_id = core_pic->core_id;
		return 0;
	}

	return -EINVAL;
}

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

	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;
		} else if (header->type == ACPI_MADT_TYPE_RINTC) {
			if (!map_rintc_hartid(header, type, acpi_id, &phys_id))
				break;
		} else if (header->type == ACPI_MADT_TYPE_CORE_PIC) {
			if (!map_core_pic_id(header, type, acpi_id, &phys_id))
				break;
		}
		entry += header->length;
	}
	return phys_id;
}

phys_cpuid_t __init acpi_map_madt_entry(u32 acpi_id)
{
	struct acpi_table_madt *madt = NULL;
	phys_cpuid_t rv;

	acpi_get_table(ACPI_SIG_MADT, 0,
		       (struct acpi_table_header **)&madt);
	if (!madt)
		return PHYS_CPUID_INVALID;

	rv = map_madt_entry(madt, 1, acpi_id);

	acpi_put_table((struct acpi_table_header *)madt);

	return rv;
}

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);
	else if (header->type == ACPI_MADT_TYPE_CORE_PIC)
		map_core_pic_id(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(get_madt_table(), type, acpi_id);

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