processor_core.c 8.8 KB
Newer Older
1 2 3 4 5 6
/*
 * Copyright (C) 2005 Intel Corporation
 * Copyright (C) 2009 Hewlett-Packard Development Company, L.P.
 *
 *	Alex Chiang <achiang@hp.com>
 *	- Unified x86/ia64 implementations
7 8 9 10
 *
 * I/O APIC hotplug support
 *	Yinghai Lu <yinghai@kernel.org>
 *	Jiang Liu <jiang.liu@intel.com>
11
 */
12
#include <linux/export.h>
13
#include <linux/acpi.h>
A
Alex Chiang 已提交
14 15 16
#include <acpi/processor.h>

#define _COMPONENT		ACPI_PROCESSOR_COMPONENT
17
ACPI_MODULE_NAME("processor_core");
A
Alex Chiang 已提交
18

19 20 21 22 23 24 25 26 27 28 29 30 31 32 33
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;
}

34
static int map_lapic_id(struct acpi_subtable_header *entry,
35
		 u32 acpi_id, phys_cpuid_t *apic_id)
36 37
{
	struct acpi_madt_local_apic *lapic =
38
		container_of(entry, struct acpi_madt_local_apic, header);
39 40

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

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

	*apic_id = lapic->id;
47
	return 0;
48 49 50
}

static int map_x2apic_id(struct acpi_subtable_header *entry,
51
		int device_declaration, u32 acpi_id, phys_cpuid_t *apic_id)
52 53
{
	struct acpi_madt_local_x2apic *apic =
54
		container_of(entry, struct acpi_madt_local_x2apic, header);
55 56

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

59 60
	if (device_declaration && (apic->uid == acpi_id)) {
		*apic_id = apic->local_apic_id;
61
		return 0;
62 63
	}

64
	return -EINVAL;
65 66 67
}

static int map_lsapic_id(struct acpi_subtable_header *entry,
68
		int device_declaration, u32 acpi_id, phys_cpuid_t *apic_id)
69 70
{
	struct acpi_madt_local_sapic *lsapic =
71
		container_of(entry, struct acpi_madt_local_sapic, header);
72 73

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

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

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

86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110
/*
 * 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;
}

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

117
	madt = get_madt_table();
118
	if (!madt)
119
		return phys_id;
120 121 122 123 124 125 126 127 128 129 130

	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) {
131
			if (!map_lapic_id(header, acpi_id, &phys_id))
132 133
				break;
		} else if (header->type == ACPI_MADT_TYPE_LOCAL_X2APIC) {
134
			if (!map_x2apic_id(header, type, acpi_id, &phys_id))
135 136
				break;
		} else if (header->type == ACPI_MADT_TYPE_LOCAL_SAPIC) {
137
			if (!map_lsapic_id(header, type, acpi_id, &phys_id))
138
				break;
139 140 141
		} else if (header->type == ACPI_MADT_TYPE_GENERIC_INTERRUPT) {
			if (!map_gicc_mpidr(header, type, acpi_id, &phys_id))
				break;
142 143 144
		}
		entry += header->length;
	}
145
	return phys_id;
146 147
}

148
static phys_cpuid_t map_mat_entry(acpi_handle handle, int type, u32 acpi_id)
149 150 151 152
{
	struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
	union acpi_object *obj;
	struct acpi_subtable_header *header;
153
	phys_cpuid_t phys_id = PHYS_CPUID_INVALID;
154 155 156 157 158 159 160 161 162 163 164 165 166 167

	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;
168
	if (header->type == ACPI_MADT_TYPE_LOCAL_APIC)
169
		map_lapic_id(header, acpi_id, &phys_id);
170
	else if (header->type == ACPI_MADT_TYPE_LOCAL_SAPIC)
171
		map_lsapic_id(header, type, acpi_id, &phys_id);
172
	else if (header->type == ACPI_MADT_TYPE_LOCAL_X2APIC)
173
		map_x2apic_id(header, type, acpi_id, &phys_id);
174 175
	else if (header->type == ACPI_MADT_TYPE_GENERIC_INTERRUPT)
		map_gicc_mpidr(header, type, acpi_id, &phys_id);
176 177

exit:
178
	kfree(buffer.pointer);
179
	return phys_id;
180 181
}

182
phys_cpuid_t acpi_get_phys_id(acpi_handle handle, int type, u32 acpi_id)
183
{
184
	phys_cpuid_t phys_id;
185

186
	phys_id = map_mat_entry(handle, type, acpi_id);
187
	if (phys_id == PHYS_CPUID_INVALID)
188
		phys_id = map_madt_entry(type, acpi_id);
189

190
	return phys_id;
191 192
}

193
int acpi_map_cpuid(phys_cpuid_t phys_id, u32 acpi_id)
194 195 196 197 198
{
#ifdef CONFIG_SMP
	int i;
#endif

199
	if (phys_id == PHYS_CPUID_INVALID) {
200 201
		/*
		 * On UP processor, there is no _MAT or MADT table.
202
		 * So above phys_id is always set to PHYS_CPUID_INVALID.
203 204 205 206 207
		 *
		 * BIOS may define multiple CPU handles even for UP processor.
		 * For example,
		 *
		 * Scope (_PR)
208
		 * {
209 210 211 212 213 214
		 *     Processor (CPU0, 0x00, 0x00000410, 0x06) {}
		 *     Processor (CPU1, 0x01, 0x00000410, 0x06) {}
		 *     Processor (CPU2, 0x02, 0x00000410, 0x06) {}
		 *     Processor (CPU3, 0x03, 0x00000410, 0x06) {}
		 * }
		 *
215
		 * Ignores phys_id and always returns 0 for the processor
216 217
		 * handle with acpi id 0 if nr_cpu_ids is 1.
		 * This should be the case if SMP tables are not found.
218 219
		 * Return -1 for other CPU's handle.
		 */
220
		if (nr_cpu_ids <= 1 && acpi_id == 0)
221 222
			return acpi_id;
		else
223
			return -1;
224
	}
225

226
#ifdef CONFIG_SMP
227
	for_each_possible_cpu(i) {
228
		if (cpu_physical_id(i) == phys_id)
229 230
			return i;
	}
231 232
#else
	/* In UP kernel, only processor 0 is valid */
233 234
	if (phys_id == 0)
		return phys_id;
235
#endif
236 237
	return -1;
}
238 239 240

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

243
	phys_id = acpi_get_phys_id(handle, type, acpi_id);
244

245
	return acpi_map_cpuid(phys_id, acpi_id);
246
}
247
EXPORT_SYMBOL_GPL(acpi_get_cpuid);
248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340

#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 */