processor_core.c 9.1 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
/*
 * Retrieve the ARM CPU physical identifier (MPIDR)
 */
static int map_gicc_mpidr(struct acpi_subtable_header *entry,
90
		int device_declaration, u32 acpi_id, phys_cpuid_t *mpidr)
91 92 93 94
{
	struct acpi_madt_generic_interrupt *gicc =
	    container_of(entry, struct acpi_madt_generic_interrupt, header);

95
	if (!(gicc->flags & ACPI_MADT_ENABLED))
96 97 98 99 100 101 102 103 104 105 106 107 108 109 110
		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(struct acpi_table_madt *madt,
112
				   int type, u32 acpi_id)
113 114
{
	unsigned long madt_end, entry;
115
	phys_cpuid_t phys_id = PHYS_CPUID_INVALID;	/* CPU hardware ID */
116 117

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

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

147 148 149 150 151
phys_cpuid_t __init acpi_map_madt_entry(u32 acpi_id)
{
	struct acpi_table_madt *madt = NULL;
	phys_cpuid_t rv;

152 153
	acpi_get_table(ACPI_SIG_MADT, 0,
		       (struct acpi_table_header **)&madt);
154 155 156
	if (!madt)
		return PHYS_CPUID_INVALID;

157
	rv = map_madt_entry(madt, 1, acpi_id);
158

159
	acpi_put_table((struct acpi_table_header *)madt);
160 161 162 163

	return rv;
}

164
static phys_cpuid_t map_mat_entry(acpi_handle handle, int type, u32 acpi_id)
165 166 167 168
{
	struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
	union acpi_object *obj;
	struct acpi_subtable_header *header;
169
	phys_cpuid_t phys_id = PHYS_CPUID_INVALID;
170 171 172 173 174 175 176 177 178 179 180 181 182 183

	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;
184
	if (header->type == ACPI_MADT_TYPE_LOCAL_APIC)
185
		map_lapic_id(header, acpi_id, &phys_id);
186
	else if (header->type == ACPI_MADT_TYPE_LOCAL_SAPIC)
187
		map_lsapic_id(header, type, acpi_id, &phys_id);
188
	else if (header->type == ACPI_MADT_TYPE_LOCAL_X2APIC)
189
		map_x2apic_id(header, type, acpi_id, &phys_id);
190
	else if (header->type == ACPI_MADT_TYPE_GENERIC_INTERRUPT)
191
		map_gicc_mpidr(header, type, acpi_id, &phys_id);
192 193

exit:
194
	kfree(buffer.pointer);
195
	return phys_id;
196 197
}

198
phys_cpuid_t acpi_get_phys_id(acpi_handle handle, int type, u32 acpi_id)
199
{
200
	phys_cpuid_t phys_id;
201

202
	phys_id = map_mat_entry(handle, type, acpi_id);
203
	if (invalid_phys_cpuid(phys_id))
204
		phys_id = map_madt_entry(get_madt_table(), type, acpi_id);
205

206
	return phys_id;
207
}
208
EXPORT_SYMBOL_GPL(acpi_get_phys_id);
209

210
int acpi_map_cpuid(phys_cpuid_t phys_id, u32 acpi_id)
211 212 213 214 215
{
#ifdef CONFIG_SMP
	int i;
#endif

216
	if (invalid_phys_cpuid(phys_id)) {
217 218
		/*
		 * On UP processor, there is no _MAT or MADT table.
219
		 * So above phys_id is always set to PHYS_CPUID_INVALID.
220 221 222 223 224
		 *
		 * BIOS may define multiple CPU handles even for UP processor.
		 * For example,
		 *
		 * Scope (_PR)
225
		 * {
226 227 228 229 230 231
		 *     Processor (CPU0, 0x00, 0x00000410, 0x06) {}
		 *     Processor (CPU1, 0x01, 0x00000410, 0x06) {}
		 *     Processor (CPU2, 0x02, 0x00000410, 0x06) {}
		 *     Processor (CPU3, 0x03, 0x00000410, 0x06) {}
		 * }
		 *
232
		 * Ignores phys_id and always returns 0 for the processor
233 234
		 * handle with acpi id 0 if nr_cpu_ids is 1.
		 * This should be the case if SMP tables are not found.
235
		 * Return -EINVAL for other CPU's handle.
236
		 */
237
		if (nr_cpu_ids <= 1 && acpi_id == 0)
238 239
			return acpi_id;
		else
240
			return -EINVAL;
241
	}
242

243
#ifdef CONFIG_SMP
244
	for_each_possible_cpu(i) {
245
		if (cpu_physical_id(i) == phys_id)
246 247
			return i;
	}
248 249
#else
	/* In UP kernel, only processor 0 is valid */
250 251
	if (phys_id == 0)
		return phys_id;
252
#endif
253
	return -ENODEV;
254
}
255 256 257

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

260
	phys_id = acpi_get_phys_id(handle, type, acpi_id);
261

262
	return acpi_map_cpuid(phys_id, acpi_id);
263
}
264
EXPORT_SYMBOL_GPL(acpi_get_cpuid);
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 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357

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