[linux-2.6-block.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, bool ignore_disabled)
{
	struct acpi_madt_local_apic *lapic =
		container_of(entry, struct acpi_madt_local_apic, header);

	if (ignore_disabled && !(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,
		bool ignore_disabled)
{
	struct acpi_madt_local_x2apic *apic =
		container_of(entry, struct acpi_madt_local_x2apic, header);

	if (ignore_disabled && !(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,
		bool ignore_disabled)
{
	struct acpi_madt_local_sapic *lsapic =
		container_of(entry, struct acpi_madt_local_sapic, header);

	if (ignore_disabled && !(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,
		bool ignore_disabled)
{
	struct acpi_madt_generic_interrupt *gicc =
	    container_of(entry, struct acpi_madt_generic_interrupt, header);

	if (ignore_disabled && !(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(struct acpi_table_madt *madt,
				   int type, u32 acpi_id, bool ignore_disabled)
{
	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,
					  ignore_disabled))
				break;
		} else if (header->type == ACPI_MADT_TYPE_LOCAL_X2APIC) {
			if (!map_x2apic_id(header, type, acpi_id, &phys_id,
					   ignore_disabled))
				break;
		} else if (header->type == ACPI_MADT_TYPE_LOCAL_SAPIC) {
			if (!map_lsapic_id(header, type, acpi_id, &phys_id,
					   ignore_disabled))
				break;
		} else if (header->type == ACPI_MADT_TYPE_GENERIC_INTERRUPT) {
			if (!map_gicc_mpidr(header, type, acpi_id, &phys_id,
					    ignore_disabled))
				break;
		}
		entry += header->length;
	}
	return phys_id;
}

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

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

	rv = map_madt_entry(madt, 1, acpi_id, true);

	early_acpi_os_unmap_memory(madt, tbl_size);

	return rv;
}

static phys_cpuid_t map_mat_entry(acpi_handle handle, int type, u32 acpi_id,
				  bool ignore_disabled)
{
	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, ignore_disabled);
	else if (header->type == ACPI_MADT_TYPE_LOCAL_SAPIC)
		map_lsapic_id(header, type, acpi_id, &phys_id, ignore_disabled);
	else if (header->type == ACPI_MADT_TYPE_LOCAL_X2APIC)
		map_x2apic_id(header, type, acpi_id, &phys_id, ignore_disabled);
	else if (header->type == ACPI_MADT_TYPE_GENERIC_INTERRUPT)
		map_gicc_mpidr(header, type, acpi_id, &phys_id,
			       ignore_disabled);

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

static phys_cpuid_t __acpi_get_phys_id(acpi_handle handle, int type,
				       u32 acpi_id, bool ignore_disabled)
{
	phys_cpuid_t phys_id;

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

	return phys_id;
}

phys_cpuid_t acpi_get_phys_id(acpi_handle handle, int type, u32 acpi_id)
{
	return __acpi_get_phys_id(handle, type, acpi_id, true);
}

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_CPU
static bool __init
map_processor(acpi_handle handle, phys_cpuid_t *phys_id, int *cpuid)
{
	int type, id;
	u32 acpi_id;
	acpi_status status;
	acpi_object_type acpi_type;
	unsigned long long tmp;
	union acpi_object object = { 0 };
	struct acpi_buffer buffer = { sizeof(union acpi_object), &object };

	status = acpi_get_type(handle, &acpi_type);
	if (ACPI_FAILURE(status))
		return false;

	switch (acpi_type) {
	case ACPI_TYPE_PROCESSOR:
		status = acpi_evaluate_object(handle, NULL, NULL, &buffer);
		if (ACPI_FAILURE(status))
			return false;
		acpi_id = object.processor.proc_id;

		/* validate the acpi_id */
		if(acpi_processor_validate_proc_id(acpi_id))
			return false;
		break;
	case ACPI_TYPE_DEVICE:
		status = acpi_evaluate_integer(handle, "_UID", NULL, &tmp);
		if (ACPI_FAILURE(status))
			return false;
		acpi_id = tmp;
		break;
	default:
		return false;
	}

	type = (acpi_type == ACPI_TYPE_DEVICE) ? 1 : 0;

	*phys_id = __acpi_get_phys_id(handle, type, acpi_id, false);
	id = acpi_map_cpuid(*phys_id, acpi_id);

	if (id < 0)
		return false;
	*cpuid = id;
	return true;
}

static acpi_status __init
set_processor_node_mapping(acpi_handle handle, u32 lvl, void *context,
			   void **rv)
{
	phys_cpuid_t phys_id;
	int cpu_id;

	if (!map_processor(handle, &phys_id, &cpu_id))
		return AE_ERROR;

	acpi_map_cpu2node(handle, cpu_id, phys_id);
	return AE_OK;
}

void __init acpi_set_processor_mapping(void)
{
	/* Set persistent cpu <-> node mapping for all processors. */
	acpi_walk_namespace(ACPI_TYPE_PROCESSOR, ACPI_ROOT_OBJECT,
			    ACPI_UINT32_MAX, set_processor_node_mapping,
			    NULL, NULL, NULL);
}
#else
void __init acpi_set_processor_mapping(void) {}
#endif /* CONFIG_ACPI_HOTPLUG_CPU */

#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,
8ad893fa	35	u32 acpi_id, phys_cpuid_t *apic_id, bool ignore_disabled)
78ed8bd2 AC	36	{
78ed8bd2 AC	37	struct acpi_madt_local_apic *lapic =
ef86c3f4	38	container_of(entry, struct acpi_madt_local_apic, header);
11130736	39
8ad893fa	40	if (ignore_disabled && !(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,
8ad893fa GZ	51	int device_declaration, u32 acpi_id, phys_cpuid_t *apic_id,
8ad893fa GZ	52	bool ignore_disabled)
78ed8bd2 AC	53	{
78ed8bd2 AC	54	struct acpi_madt_local_x2apic *apic =
ef86c3f4	55	container_of(entry, struct acpi_madt_local_x2apic, header);
78ed8bd2	56
8ad893fa	57	if (ignore_disabled && !(apic->lapic_flags & ACPI_MADT_ENABLED))
038d7b59	58	return -ENODEV;
78ed8bd2	59
d6742095 AC	60	if (device_declaration && (apic->uid == acpi_id)) {
d6742095 AC	61	*apic_id = apic->local_apic_id;
038d7b59	62	return 0;
78ed8bd2 AC	63	}
78ed8bd2 AC	64
038d7b59	65	return -EINVAL;
78ed8bd2 AC	66	}
	67
	68	static int map_lsapic_id(struct acpi_subtable_header *entry,
8ad893fa GZ	69	int device_declaration, u32 acpi_id, phys_cpuid_t *apic_id,
8ad893fa GZ	70	bool ignore_disabled)
78ed8bd2 AC	71	{
78ed8bd2 AC	72	struct acpi_madt_local_sapic *lsapic =
ef86c3f4	73	container_of(entry, struct acpi_madt_local_sapic, header);
78ed8bd2	74
8ad893fa	75	if (ignore_disabled && !(lsapic->lapic_flags & ACPI_MADT_ENABLED))
038d7b59	76	return -ENODEV;
78ed8bd2	77
78ed8bd2	78	if (device_declaration) {
eae701ce	79	if ((entry->length < 16) \|\| (lsapic->uid != acpi_id))
038d7b59	80	return -EINVAL;
eae701ce	81	} else if (lsapic->processor_id != acpi_id)
038d7b59	82	return -EINVAL;
78ed8bd2	83
eae701ce	84	*apic_id = (lsapic->id << 8) \| lsapic->eid;
038d7b59	85	return 0;
78ed8bd2 AC	86	}
78ed8bd2 AC	87
020295b4 HG	88	/*
	89	* Retrieve the ARM CPU physical identifier (MPIDR)
	90	*/
	91	static int map_gicc_mpidr(struct acpi_subtable_header *entry,
8ad893fa GZ	92	int device_declaration, u32 acpi_id, phys_cpuid_t *mpidr,
8ad893fa GZ	93	bool ignore_disabled)
020295b4 HG	94	{
	95	struct acpi_madt_generic_interrupt *gicc =
	96	container_of(entry, struct acpi_madt_generic_interrupt, header);
	97
8ad893fa	98	if (ignore_disabled && !(gicc->flags & ACPI_MADT_ENABLED))
020295b4 HG	99	return -ENODEV;
	100
	101	/* device_declaration means Device object in DSDT, in the
	102	* GIC interrupt model, logical processors are required to
	103	* have a Processor Device object in the DSDT, so we should
	104	* check device_declaration here
	105	*/
	106	if (device_declaration && (gicc->uid == acpi_id)) {
	107	*mpidr = gicc->arm_mpidr;
	108	return 0;
	109	}
	110
	111	return -EINVAL;
	112	}
	113
fb7c2bae	114	static phys_cpuid_t map_madt_entry(struct acpi_table_madt *madt,
8ad893fa	115	int type, u32 acpi_id, bool ignore_disabled)
78ed8bd2 AC	116	{
78ed8bd2 AC	117	unsigned long madt_end, entry;
828aef37	118	phys_cpuid_t phys_id = PHYS_CPUID_INVALID; /* CPU hardware ID */
78ed8bd2 AC	119
78ed8bd2 AC	120	if (!madt)
af8f3f51	121	return phys_id;
78ed8bd2 AC	122
	123	entry = (unsigned long)madt;
	124	madt_end = entry + madt->header.length;
	125
	126	/* Parse all entries looking for a match. */
	127
	128	entry += sizeof(struct acpi_table_madt);
	129	while (entry + sizeof(struct acpi_subtable_header) < madt_end) {
	130	struct acpi_subtable_header *header =
	131	(struct acpi_subtable_header *)entry;
	132	if (header->type == ACPI_MADT_TYPE_LOCAL_APIC) {
8ad893fa GZ	133	if (!map_lapic_id(header, acpi_id, &phys_id,
8ad893fa GZ	134	ignore_disabled))
78ed8bd2 AC	135	break;
78ed8bd2 AC	136	} else if (header->type == ACPI_MADT_TYPE_LOCAL_X2APIC) {
8ad893fa GZ	137	if (!map_x2apic_id(header, type, acpi_id, &phys_id,
8ad893fa GZ	138	ignore_disabled))
78ed8bd2 AC	139	break;
78ed8bd2 AC	140	} else if (header->type == ACPI_MADT_TYPE_LOCAL_SAPIC) {
8ad893fa GZ	141	if (!map_lsapic_id(header, type, acpi_id, &phys_id,
8ad893fa GZ	142	ignore_disabled))
78ed8bd2	143	break;
020295b4	144	} else if (header->type == ACPI_MADT_TYPE_GENERIC_INTERRUPT) {
8ad893fa GZ	145	if (!map_gicc_mpidr(header, type, acpi_id, &phys_id,
8ad893fa GZ	146	ignore_disabled))
020295b4	147	break;
78ed8bd2 AC	148	}
	149	entry += header->length;
	150	}
af8f3f51	151	return phys_id;
78ed8bd2 AC	152	}
78ed8bd2 AC	153
fb7c2bae DD	154	phys_cpuid_t __init acpi_map_madt_entry(u32 acpi_id)
	155	{
	156	struct acpi_table_madt *madt = NULL;
	157	acpi_size tbl_size;
	158	phys_cpuid_t rv;
	159
	160	acpi_get_table_with_size(ACPI_SIG_MADT, 0,
	161	(struct acpi_table_header **)&madt,
	162	&tbl_size);
	163	if (!madt)
	164	return PHYS_CPUID_INVALID;
	165
8ad893fa	166	rv = map_madt_entry(madt, 1, acpi_id, true);
fb7c2bae DD	167
	168	early_acpi_os_unmap_memory(madt, tbl_size);
	169
	170	return rv;
	171	}
	172
8ad893fa GZ	173	static phys_cpuid_t map_mat_entry(acpi_handle handle, int type, u32 acpi_id,
8ad893fa GZ	174	bool ignore_disabled)
78ed8bd2 AC	175	{
	176	struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
	177	union acpi_object *obj;
	178	struct acpi_subtable_header *header;
828aef37	179	phys_cpuid_t phys_id = PHYS_CPUID_INVALID;
78ed8bd2 AC	180
	181	if (ACPI_FAILURE(acpi_evaluate_object(handle, "_MAT", NULL, &buffer)))
	182	goto exit;
	183
	184	if (!buffer.length \|\| !buffer.pointer)
	185	goto exit;
	186
	187	obj = buffer.pointer;
	188	if (obj->type != ACPI_TYPE_BUFFER \|\|
	189	obj->buffer.length < sizeof(struct acpi_subtable_header)) {
	190	goto exit;
	191	}
	192
	193	header = (struct acpi_subtable_header *)obj->buffer.pointer;
13ca62b2	194	if (header->type == ACPI_MADT_TYPE_LOCAL_APIC)
8ad893fa	195	map_lapic_id(header, acpi_id, &phys_id, ignore_disabled);
13ca62b2	196	else if (header->type == ACPI_MADT_TYPE_LOCAL_SAPIC)
8ad893fa	197	map_lsapic_id(header, type, acpi_id, &phys_id, ignore_disabled);
13ca62b2	198	else if (header->type == ACPI_MADT_TYPE_LOCAL_X2APIC)
8ad893fa	199	map_x2apic_id(header, type, acpi_id, &phys_id, ignore_disabled);
020295b4	200	else if (header->type == ACPI_MADT_TYPE_GENERIC_INTERRUPT)
8ad893fa GZ	201	map_gicc_mpidr(header, type, acpi_id, &phys_id,
8ad893fa GZ	202	ignore_disabled);
78ed8bd2 AC	203
78ed8bd2 AC	204	exit:
5273a258	205	kfree(buffer.pointer);
af8f3f51	206	return phys_id;
78ed8bd2 AC	207	}
78ed8bd2 AC	208
8ad893fa GZ	209	static phys_cpuid_t __acpi_get_phys_id(acpi_handle handle, int type,
8ad893fa GZ	210	u32 acpi_id, bool ignore_disabled)
78ed8bd2	211	{
828aef37	212	phys_cpuid_t phys_id;
78ed8bd2	213
8ad893fa	214	phys_id = map_mat_entry(handle, type, acpi_id, ignore_disabled);
ddcc18f5	215	if (invalid_phys_cpuid(phys_id))
8ad893fa GZ	216	phys_id = map_madt_entry(get_madt_table(), type, acpi_id,
8ad893fa GZ	217	ignore_disabled);
ca9f62ac	218
af8f3f51	219	return phys_id;
ca9f62ac JL	220	}
ca9f62ac JL	221
8ad893fa GZ	222	phys_cpuid_t acpi_get_phys_id(acpi_handle handle, int type, u32 acpi_id)
	223	{
	224	return __acpi_get_phys_id(handle, type, acpi_id, true);
	225	}
	226
828aef37	227	int acpi_map_cpuid(phys_cpuid_t phys_id, u32 acpi_id)
ca9f62ac JL	228	{
	229	#ifdef CONFIG_SMP
	230	int i;
	231	#endif
	232
ddcc18f5	233	if (invalid_phys_cpuid(phys_id)) {
d640113f LM	234	/*
d640113f LM	235	* On UP processor, there is no _MAT or MADT table.
828aef37	236	* So above phys_id is always set to PHYS_CPUID_INVALID.
d640113f LM	237	*
	238	* BIOS may define multiple CPU handles even for UP processor.
	239	* For example,
	240	*
	241	* Scope (_PR)
13ca62b2	242	* {
d640113f LM	243	* Processor (CPU0, 0x00, 0x00000410, 0x06) {}
	244	* Processor (CPU1, 0x01, 0x00000410, 0x06) {}
	245	* Processor (CPU2, 0x02, 0x00000410, 0x06) {}
	246	* Processor (CPU3, 0x03, 0x00000410, 0x06) {}
	247	* }
	248	*
af8f3f51	249	* Ignores phys_id and always returns 0 for the processor
c4686c71 TR	250	* handle with acpi id 0 if nr_cpu_ids is 1.
c4686c71 TR	251	* This should be the case if SMP tables are not found.
d3da7cb9	252	* Return -EINVAL for other CPU's handle.
d640113f	253	*/
c4686c71	254	if (nr_cpu_ids <= 1 && acpi_id == 0)
d640113f LM	255	return acpi_id;
d640113f LM	256	else
d3da7cb9	257	return -EINVAL;
d640113f	258	}
78ed8bd2	259
932df741	260	#ifdef CONFIG_SMP
78ed8bd2	261	for_each_possible_cpu(i) {
af8f3f51	262	if (cpu_physical_id(i) == phys_id)
78ed8bd2 AC	263	return i;
78ed8bd2 AC	264	}
932df741 LM	265	#else
932df741 LM	266	/* In UP kernel, only processor 0 is valid */
af8f3f51 HG	267	if (phys_id == 0)
af8f3f51 HG	268	return phys_id;
932df741	269	#endif
d3da7cb9	270	return -ENODEV;
78ed8bd2	271	}
ca9f62ac JL	272
	273	int acpi_get_cpuid(acpi_handle handle, int type, u32 acpi_id)
	274	{
828aef37	275	phys_cpuid_t phys_id;
ca9f62ac	276
af8f3f51	277	phys_id = acpi_get_phys_id(handle, type, acpi_id);
ca9f62ac	278
af8f3f51	279	return acpi_map_cpuid(phys_id, acpi_id);
ca9f62ac	280	}
78ed8bd2	281	EXPORT_SYMBOL_GPL(acpi_get_cpuid);
ecf5636d	282
dc6db24d GZ	283	#ifdef CONFIG_ACPI_HOTPLUG_CPU
	284	static bool __init
	285	map_processor(acpi_handle handle, phys_cpuid_t phys_id, int cpuid)
	286	{
c183a603	287	int type, id;
dc6db24d GZ	288	u32 acpi_id;
	289	acpi_status status;
	290	acpi_object_type acpi_type;
	291	unsigned long long tmp;
	292	union acpi_object object = { 0 };
	293	struct acpi_buffer buffer = { sizeof(union acpi_object), &object };
	294
	295	status = acpi_get_type(handle, &acpi_type);
	296	if (ACPI_FAILURE(status))
	297	return false;
	298
	299	switch (acpi_type) {
	300	case ACPI_TYPE_PROCESSOR:
	301	status = acpi_evaluate_object(handle, NULL, NULL, &buffer);
	302	if (ACPI_FAILURE(status))
	303	return false;
	304	acpi_id = object.processor.proc_id;
fd74da21 DL	305
	306	/* validate the acpi_id */
	307	if(acpi_processor_validate_proc_id(acpi_id))
	308	return false;
dc6db24d GZ	309	break;
	310	case ACPI_TYPE_DEVICE:
	311	status = acpi_evaluate_integer(handle, "_UID", NULL, &tmp);
	312	if (ACPI_FAILURE(status))
	313	return false;
	314	acpi_id = tmp;
	315	break;
	316	default:
	317	return false;
	318	}
	319
	320	type = (acpi_type == ACPI_TYPE_DEVICE) ? 1 : 0;
	321
	322	*phys_id = __acpi_get_phys_id(handle, type, acpi_id, false);
c183a603	323	id = acpi_map_cpuid(*phys_id, acpi_id);
dc6db24d	324
c183a603 TG	325	if (id < 0)
	326	return false;
	327	*cpuid = id;
dc6db24d GZ	328	return true;
	329	}
	330
	331	static acpi_status __init
	332	set_processor_node_mapping(acpi_handle handle, u32 lvl, void *context,
	333	void **rv)
	334	{
	335	phys_cpuid_t phys_id;
	336	int cpu_id;
	337
	338	if (!map_processor(handle, &phys_id, &cpu_id))
	339	return AE_ERROR;
	340
	341	acpi_map_cpu2node(handle, cpu_id, phys_id);
	342	return AE_OK;
	343	}
	344
	345	void __init acpi_set_processor_mapping(void)
	346	{
	347	/* Set persistent cpu <-> node mapping for all processors. */
	348	acpi_walk_namespace(ACPI_TYPE_PROCESSOR, ACPI_ROOT_OBJECT,
	349	ACPI_UINT32_MAX, set_processor_node_mapping,
	350	NULL, NULL, NULL);
	351	}
	352	#else
	353	void __init acpi_set_processor_mapping(void) {}
	354	#endif /* CONFIG_ACPI_HOTPLUG_CPU */
	355
ecf5636d YL	356	#ifdef CONFIG_ACPI_HOTPLUG_IOAPIC
	357	static int get_ioapic_id(struct acpi_subtable_header *entry, u32 gsi_base,
	358	u64 phys_addr, int ioapic_id)
	359	{
	360	struct acpi_madt_io_apic ioapic = (struct acpi_madt_io_apic )entry;
	361
	362	if (ioapic->global_irq_base != gsi_base)
	363	return 0;
	364
	365	*phys_addr = ioapic->address;
	366	*ioapic_id = ioapic->id;
	367	return 1;
	368	}
	369
	370	static int parse_madt_ioapic_entry(u32 gsi_base, u64 *phys_addr)
	371	{
	372	struct acpi_subtable_header *hdr;
	373	unsigned long madt_end, entry;
	374	struct acpi_table_madt *madt;
	375	int apic_id = -1;
	376
	377	madt = get_madt_table();
	378	if (!madt)
	379	return apic_id;
	380
	381	entry = (unsigned long)madt;
	382	madt_end = entry + madt->header.length;
	383
	384	/* Parse all entries looking for a match. */
	385	entry += sizeof(struct acpi_table_madt);
	386	while (entry + sizeof(struct acpi_subtable_header) < madt_end) {
	387	hdr = (struct acpi_subtable_header *)entry;
	388	if (hdr->type == ACPI_MADT_TYPE_IO_APIC &&
	389	get_ioapic_id(hdr, gsi_base, phys_addr, &apic_id))
	390	break;
	391	else
	392	entry += hdr->length;
	393	}
	394
	395	return apic_id;
	396	}
	397
	398	static int parse_mat_ioapic_entry(acpi_handle handle, u32 gsi_base,
	399	u64 *phys_addr)
	400	{
	401	struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
	402	struct acpi_subtable_header *header;
	403	union acpi_object *obj;
	404	int apic_id = -1;
	405
	406	if (ACPI_FAILURE(acpi_evaluate_object(handle, "_MAT", NULL, &buffer)))
	407	goto exit;
	408
	409	if (!buffer.length \|\| !buffer.pointer)
	410	goto exit;
	411
	412	obj = buffer.pointer;
	413	if (obj->type != ACPI_TYPE_BUFFER \|\|
	414	obj->buffer.length < sizeof(struct acpi_subtable_header))
	415	goto exit;
	416
	417	header = (struct acpi_subtable_header *)obj->buffer.pointer;
	418	if (header->type == ACPI_MADT_TYPE_IO_APIC)
	419	get_ioapic_id(header, gsi_base, phys_addr, &apic_id);
420
421	exit:
422	kfree(buffer.pointer);
423	return apic_id;
424	}
425
426	/**
427	* acpi_get_ioapic_id - Get IOAPIC ID and physical address matching @gsi_base
428	* @handle: ACPI object for IOAPIC device
429	* @gsi_base: GSI base to match with
430	* @phys_addr: Pointer to store physical address of matching IOAPIC record
431	*
432	* Walk resources returned by ACPI_MAT method, then ACPI MADT table, to search
433	* for an ACPI IOAPIC record matching @gsi_base.
434	* Return IOAPIC id and store physical address in @phys_addr if found a match,
435	* otherwise return <0.
436	*/
437	int acpi_get_ioapic_id(acpi_handle handle, u32 gsi_base, u64 *phys_addr)
438	{
439	int apic_id;
440
441	apic_id = parse_mat_ioapic_entry(handle, gsi_base, phys_addr);
442	if (apic_id == -1)
443	apic_id = parse_madt_ioapic_entry(gsi_base, phys_addr);
444
445	return apic_id;
446	}
447	#endif /* CONFIG_ACPI_HOTPLUG_IOAPIC */