Linux Audio

Check our new training course

Loading...
v4.6
  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
  7 *
  8 * I/O APIC hotplug support
  9 *	Yinghai Lu <yinghai@kernel.org>
 10 *	Jiang Liu <jiang.liu@intel.com>
 11 */
 12#include <linux/export.h>
 
 
 13#include <linux/acpi.h>
 14#include <acpi/processor.h>
 15
 
 
 16#define _COMPONENT		ACPI_PROCESSOR_COMPONENT
 17ACPI_MODULE_NAME("processor_core");
 18
 19static 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
 34static 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
 50static 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	if (device_declaration && (apic->uid == acpi_id)) {
 60		*apic_id = apic->local_apic_id;
 61		return 0;
 62	}
 63
 64	return -EINVAL;
 65}
 66
 67static 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 * Retrieve the ARM CPU physical identifier (MPIDR)
 88 */
 89static 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
111static 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	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) {
131			if (!map_lapic_id(header, acpi_id, &phys_id))
132				break;
133		} else if (header->type == ACPI_MADT_TYPE_LOCAL_X2APIC) {
134			if (!map_x2apic_id(header, type, acpi_id, &phys_id))
135				break;
136		} else if (header->type == ACPI_MADT_TYPE_LOCAL_SAPIC) {
137			if (!map_lsapic_id(header, type, acpi_id, &phys_id))
138				break;
139		} else if (header->type == ACPI_MADT_TYPE_GENERIC_INTERRUPT) {
140			if (!map_gicc_mpidr(header, type, acpi_id, &phys_id))
141				break;
142		}
143		entry += header->length;
144	}
145	return phys_id;
146}
147
148static phys_cpuid_t map_mat_entry(acpi_handle handle, int type, u32 acpi_id)
149{
150	struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
151	union acpi_object *obj;
152	struct acpi_subtable_header *header;
153	phys_cpuid_t phys_id = PHYS_CPUID_INVALID;
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;
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	else if (header->type == ACPI_MADT_TYPE_GENERIC_INTERRUPT)
175		map_gicc_mpidr(header, type, acpi_id, &phys_id);
176
177exit:
178	kfree(buffer.pointer);
179	return phys_id;
180}
181
182phys_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 (invalid_phys_cpuid(phys_id))
188		phys_id = map_madt_entry(type, acpi_id);
189
190	return phys_id;
191}
192
193int acpi_map_cpuid(phys_cpuid_t phys_id, u32 acpi_id)
194{
195#ifdef CONFIG_SMP
196	int i;
197#endif
198
199	if (invalid_phys_cpuid(phys_id)) {
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		 * BIOS may define multiple CPU handles even for UP processor.
205		 * For example,
206		 *
207		 * Scope (_PR)
208		 * {
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		 *
215		 * Ignores phys_id and always returns 0 for the processor
216		 * handle with acpi id 0 if nr_cpu_ids is 1.
217		 * This should be the case if SMP tables are not found.
218		 * Return -EINVAL for other CPU's handle.
219		 */
220		if (nr_cpu_ids <= 1 && acpi_id == 0)
221			return acpi_id;
222		else
223			return -EINVAL;
224	}
225
226#ifdef CONFIG_SMP
227	for_each_possible_cpu(i) {
228		if (cpu_physical_id(i) == phys_id)
229			return i;
230	}
231#else
232	/* In UP kernel, only processor 0 is valid */
233	if (phys_id == 0)
234		return phys_id;
235#endif
236	return -ENODEV;
237}
238
239int acpi_get_cpuid(acpi_handle handle, int type, u32 acpi_id)
240{
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}
247EXPORT_SYMBOL_GPL(acpi_get_cpuid);
248
249#ifdef CONFIG_ACPI_HOTPLUG_IOAPIC
250static 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
263static 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
291static 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
314exit:
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 */
330int 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 */
v3.15
  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
  7 *	Venkatesh Pallipadi <venkatesh.pallipadi@intel.com>
  8 *	- Added _PDC for platforms with Intel CPUs
 
 
  9 */
 10#include <linux/export.h>
 11#include <linux/dmi.h>
 12#include <linux/slab.h>
 13#include <linux/acpi.h>
 14#include <acpi/processor.h>
 15
 16#include "internal.h"
 17
 18#define _COMPONENT		ACPI_PROCESSOR_COMPONENT
 19ACPI_MODULE_NAME("processor_core");
 20
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 21static int map_lapic_id(struct acpi_subtable_header *entry,
 22		 u32 acpi_id, int *apic_id)
 23{
 24	struct acpi_madt_local_apic *lapic =
 25		(struct acpi_madt_local_apic *)entry;
 26
 27	if (!(lapic->lapic_flags & ACPI_MADT_ENABLED))
 28		return -ENODEV;
 29
 30	if (lapic->processor_id != acpi_id)
 31		return -EINVAL;
 32
 33	*apic_id = lapic->id;
 34	return 0;
 35}
 36
 37static int map_x2apic_id(struct acpi_subtable_header *entry,
 38			 int device_declaration, u32 acpi_id, int *apic_id)
 39{
 40	struct acpi_madt_local_x2apic *apic =
 41		(struct acpi_madt_local_x2apic *)entry;
 42
 43	if (!(apic->lapic_flags & ACPI_MADT_ENABLED))
 44		return -ENODEV;
 45
 46	if (device_declaration && (apic->uid == acpi_id)) {
 47		*apic_id = apic->local_apic_id;
 48		return 0;
 49	}
 50
 51	return -EINVAL;
 52}
 53
 54static int map_lsapic_id(struct acpi_subtable_header *entry,
 55		int device_declaration, u32 acpi_id, int *apic_id)
 56{
 57	struct acpi_madt_local_sapic *lsapic =
 58		(struct acpi_madt_local_sapic *)entry;
 59
 60	if (!(lsapic->lapic_flags & ACPI_MADT_ENABLED))
 61		return -ENODEV;
 62
 63	if (device_declaration) {
 64		if ((entry->length < 16) || (lsapic->uid != acpi_id))
 65			return -EINVAL;
 66	} else if (lsapic->processor_id != acpi_id)
 67		return -EINVAL;
 68
 69	*apic_id = (lsapic->id << 8) | lsapic->eid;
 70	return 0;
 71}
 72
 73static int map_madt_entry(int type, u32 acpi_id)
 
 
 
 
 74{
 75	unsigned long madt_end, entry;
 76	static struct acpi_table_madt *madt;
 77	static int read_madt;
 78	int apic_id = -1;
 
 79
 80	if (!read_madt) {
 81		if (ACPI_FAILURE(acpi_get_table(ACPI_SIG_MADT, 0,
 82					(struct acpi_table_header **)&madt)))
 83			madt = NULL;
 84		read_madt++;
 
 
 
 85	}
 86
 
 
 
 
 
 
 
 
 
 
 87	if (!madt)
 88		return apic_id;
 89
 90	entry = (unsigned long)madt;
 91	madt_end = entry + madt->header.length;
 92
 93	/* Parse all entries looking for a match. */
 94
 95	entry += sizeof(struct acpi_table_madt);
 96	while (entry + sizeof(struct acpi_subtable_header) < madt_end) {
 97		struct acpi_subtable_header *header =
 98			(struct acpi_subtable_header *)entry;
 99		if (header->type == ACPI_MADT_TYPE_LOCAL_APIC) {
100			if (!map_lapic_id(header, acpi_id, &apic_id))
101				break;
102		} else if (header->type == ACPI_MADT_TYPE_LOCAL_X2APIC) {
103			if (!map_x2apic_id(header, type, acpi_id, &apic_id))
104				break;
105		} else if (header->type == ACPI_MADT_TYPE_LOCAL_SAPIC) {
106			if (!map_lsapic_id(header, type, acpi_id, &apic_id))
 
 
 
107				break;
108		}
109		entry += header->length;
110	}
111	return apic_id;
112}
113
114static int map_mat_entry(acpi_handle handle, int type, u32 acpi_id)
115{
116	struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
117	union acpi_object *obj;
118	struct acpi_subtable_header *header;
119	int apic_id = -1;
120
121	if (ACPI_FAILURE(acpi_evaluate_object(handle, "_MAT", NULL, &buffer)))
122		goto exit;
123
124	if (!buffer.length || !buffer.pointer)
125		goto exit;
126
127	obj = buffer.pointer;
128	if (obj->type != ACPI_TYPE_BUFFER ||
129	    obj->buffer.length < sizeof(struct acpi_subtable_header)) {
130		goto exit;
131	}
132
133	header = (struct acpi_subtable_header *)obj->buffer.pointer;
134	if (header->type == ACPI_MADT_TYPE_LOCAL_APIC) {
135		map_lapic_id(header, acpi_id, &apic_id);
136	} else if (header->type == ACPI_MADT_TYPE_LOCAL_SAPIC) {
137		map_lsapic_id(header, type, acpi_id, &apic_id);
138	}
 
 
 
139
140exit:
141	kfree(buffer.pointer);
142	return apic_id;
143}
144
145int acpi_get_apicid(acpi_handle handle, int type, u32 acpi_id)
146{
147	int apic_id;
148
149	apic_id = map_mat_entry(handle, type, acpi_id);
150	if (apic_id == -1)
151		apic_id = map_madt_entry(type, acpi_id);
152
153	return apic_id;
154}
155
156int acpi_map_cpuid(int apic_id, u32 acpi_id)
157{
158#ifdef CONFIG_SMP
159	int i;
160#endif
161
162	if (apic_id == -1) {
163		/*
164		 * On UP processor, there is no _MAT or MADT table.
165		 * So above apic_id is always set to -1.
166		 *
167		 * BIOS may define multiple CPU handles even for UP processor.
168		 * For example,
169		 *
170		 * Scope (_PR)
171                 * {
172		 *     Processor (CPU0, 0x00, 0x00000410, 0x06) {}
173		 *     Processor (CPU1, 0x01, 0x00000410, 0x06) {}
174		 *     Processor (CPU2, 0x02, 0x00000410, 0x06) {}
175		 *     Processor (CPU3, 0x03, 0x00000410, 0x06) {}
176		 * }
177		 *
178		 * Ignores apic_id and always returns 0 for the processor
179		 * handle with acpi id 0 if nr_cpu_ids is 1.
180		 * This should be the case if SMP tables are not found.
181		 * Return -1 for other CPU's handle.
182		 */
183		if (nr_cpu_ids <= 1 && acpi_id == 0)
184			return acpi_id;
185		else
186			return apic_id;
187	}
188
189#ifdef CONFIG_SMP
190	for_each_possible_cpu(i) {
191		if (cpu_physical_id(i) == apic_id)
192			return i;
193	}
194#else
195	/* In UP kernel, only processor 0 is valid */
196	if (apic_id == 0)
197		return apic_id;
198#endif
199	return -1;
200}
201
202int acpi_get_cpuid(acpi_handle handle, int type, u32 acpi_id)
203{
204	int apic_id;
205
206	apic_id = acpi_get_apicid(handle, type, acpi_id);
207
208	return acpi_map_cpuid(apic_id, acpi_id);
209}
210EXPORT_SYMBOL_GPL(acpi_get_cpuid);
211
212static bool __init processor_physically_present(acpi_handle handle)
 
 
213{
214	int cpuid, type;
215	u32 acpi_id;
216	acpi_status status;
217	acpi_object_type acpi_type;
218	unsigned long long tmp;
219	union acpi_object object = { 0 };
220	struct acpi_buffer buffer = { sizeof(union acpi_object), &object };
221
222	status = acpi_get_type(handle, &acpi_type);
223	if (ACPI_FAILURE(status))
224		return false;
225
226	switch (acpi_type) {
227	case ACPI_TYPE_PROCESSOR:
228		status = acpi_evaluate_object(handle, NULL, NULL, &buffer);
229		if (ACPI_FAILURE(status))
230			return false;
231		acpi_id = object.processor.proc_id;
232		break;
233	case ACPI_TYPE_DEVICE:
234		status = acpi_evaluate_integer(handle, "_UID", NULL, &tmp);
235		if (ACPI_FAILURE(status))
236			return false;
237		acpi_id = tmp;
238		break;
239	default:
240		return false;
241	}
242
243	type = (acpi_type == ACPI_TYPE_DEVICE) ? 1 : 0;
244	cpuid = acpi_get_cpuid(handle, type, acpi_id);
245
246	if (cpuid == -1)
247		return false;
248
249	return true;
 
 
250}
251
252static void acpi_set_pdc_bits(u32 *buf)
253{
254	buf[0] = ACPI_PDC_REVISION_ID;
255	buf[1] = 1;
 
 
256
257	/* Enable coordination with firmware's _TSD info */
258	buf[2] = ACPI_PDC_SMP_T_SWCOORD;
 
259
260	/* Twiddle arch-specific bits needed for _PDC */
261	arch_acpi_set_pdc_bits(buf);
262}
263
264static struct acpi_object_list *acpi_processor_alloc_pdc(void)
265{
266	struct acpi_object_list *obj_list;
267	union acpi_object *obj;
268	u32 *buf;
269
270	/* allocate and initialize pdc. It will be used later. */
271	obj_list = kmalloc(sizeof(struct acpi_object_list), GFP_KERNEL);
272	if (!obj_list) {
273		printk(KERN_ERR "Memory allocation error\n");
274		return NULL;
275	}
276
277	obj = kmalloc(sizeof(union acpi_object), GFP_KERNEL);
278	if (!obj) {
279		printk(KERN_ERR "Memory allocation error\n");
280		kfree(obj_list);
281		return NULL;
282	}
283
284	buf = kmalloc(12, GFP_KERNEL);
285	if (!buf) {
286		printk(KERN_ERR "Memory allocation error\n");
287		kfree(obj);
288		kfree(obj_list);
289		return NULL;
290	}
291
292	acpi_set_pdc_bits(buf);
293
294	obj->type = ACPI_TYPE_BUFFER;
295	obj->buffer.length = 12;
296	obj->buffer.pointer = (u8 *) buf;
297	obj_list->count = 1;
298	obj_list->pointer = obj;
299
300	return obj_list;
301}
302
303/*
304 * _PDC is required for a BIOS-OS handshake for most of the newer
305 * ACPI processor features.
306 */
307static acpi_status
308acpi_processor_eval_pdc(acpi_handle handle, struct acpi_object_list *pdc_in)
309{
310	acpi_status status = AE_OK;
 
 
 
311
312	if (boot_option_idle_override == IDLE_NOMWAIT) {
313		/*
314		 * If mwait is disabled for CPU C-states, the C2C3_FFH access
315		 * mode will be disabled in the parameter of _PDC object.
316		 * Of course C1_FFH access mode will also be disabled.
317		 */
318		union acpi_object *obj;
319		u32 *buffer = NULL;
320
321		obj = pdc_in->pointer;
322		buffer = (u32 *)(obj->buffer.pointer);
323		buffer[2] &= ~(ACPI_PDC_C_C2C3_FFH | ACPI_PDC_C_C1_FFH);
324
325	}
326	status = acpi_evaluate_object(handle, "_PDC", pdc_in, NULL);
 
 
327
328	if (ACPI_FAILURE(status))
329		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
330		    "Could not evaluate _PDC, using legacy perf. control.\n"));
331
332	return status;
 
 
333}
334
335void acpi_processor_set_pdc(acpi_handle handle)
 
 
 
 
 
 
 
 
 
 
 
336{
337	struct acpi_object_list *obj_list;
338
339	if (arch_has_acpi_pdc() == false)
340		return;
 
341
342	obj_list = acpi_processor_alloc_pdc();
343	if (!obj_list)
344		return;
345
346	acpi_processor_eval_pdc(handle, obj_list);
347
348	kfree(obj_list->pointer->buffer.pointer);
349	kfree(obj_list->pointer);
350	kfree(obj_list);
351}
352
353static acpi_status __init
354early_init_pdc(acpi_handle handle, u32 lvl, void *context, void **rv)
355{
356	if (processor_physically_present(handle) == false)
357		return AE_OK;
358
359	acpi_processor_set_pdc(handle);
360	return AE_OK;
361}
362
363#if defined(CONFIG_X86) || defined(CONFIG_IA64)
364static int __init set_no_mwait(const struct dmi_system_id *id)
365{
366	pr_notice(PREFIX "%s detected - disabling mwait for CPU C-states\n",
367		  id->ident);
368	boot_option_idle_override = IDLE_NOMWAIT;
369	return 0;
370}
371
372static struct dmi_system_id processor_idle_dmi_table[] __initdata = {
373	{
374	set_no_mwait, "Extensa 5220", {
375	DMI_MATCH(DMI_BIOS_VENDOR, "Phoenix Technologies LTD"),
376	DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
377	DMI_MATCH(DMI_PRODUCT_VERSION, "0100"),
378	DMI_MATCH(DMI_BOARD_NAME, "Columbia") }, NULL},
379	{},
380};
381
382static void __init processor_dmi_check(void)
383{
384	/*
385	 * Check whether the system is DMI table. If yes, OSPM
386	 * should not use mwait for CPU-states.
387	 */
388	dmi_check_system(processor_idle_dmi_table);
389}
390#else
391static inline void processor_dmi_check(void) {}
392#endif
393
394void __init acpi_early_processor_set_pdc(void)
395{
396	processor_dmi_check();
397
398	acpi_walk_namespace(ACPI_TYPE_PROCESSOR, ACPI_ROOT_OBJECT,
399			    ACPI_UINT32_MAX,
400			    early_init_pdc, NULL, NULL, NULL);
401	acpi_get_devices(ACPI_PROCESSOR_DEVICE_HID, early_init_pdc, NULL, NULL);
402}