processor_core.c 9.4 KB
Newer Older
1 2 3 4 5 6 7 8 9
/*
 * Copyright (C) 2005 Intel Corporation
 * Copyright (C) 2009 Hewlett-Packard Development Company, L.P.
 *
 *	Alex Chiang <achiang@hp.com>
 *	- Unified x86/ia64 implementations
 *	Venkatesh Pallipadi <venkatesh.pallipadi@intel.com>
 *	- Added _PDC for platforms with Intel CPUs
 */
10
#include <linux/export.h>
A
Alex Chiang 已提交
11
#include <linux/dmi.h>
12
#include <linux/slab.h>
13
#include <linux/acpi.h>
A
Alex Chiang 已提交
14 15 16 17 18
#include <acpi/processor.h>

#include "internal.h"

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

21 22 23 24 25
static int map_lapic_id(struct acpi_subtable_header *entry,
		 u32 acpi_id, int *apic_id)
{
	struct acpi_madt_local_apic *lapic =
		(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 37 38 39 40 41 42 43
}

static int map_x2apic_id(struct acpi_subtable_header *entry,
			 int device_declaration, u32 acpi_id, int *apic_id)
{
	struct acpi_madt_local_x2apic *apic =
		(struct acpi_madt_local_x2apic *)entry;

	if (!(apic->lapic_flags & ACPI_MADT_ENABLED))
44
		return -ENODEV;
45

46 47
	if (device_declaration && (apic->uid == acpi_id)) {
		*apic_id = apic->local_apic_id;
48
		return 0;
49 50
	}

51
	return -EINVAL;
52 53 54 55 56 57 58 59 60
}

static int map_lsapic_id(struct acpi_subtable_header *entry,
		int device_declaration, u32 acpi_id, int *apic_id)
{
	struct acpi_madt_local_sapic *lsapic =
		(struct acpi_madt_local_sapic *)entry;

	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 73 74 75
}

static int map_madt_entry(int type, u32 acpi_id)
{
	unsigned long madt_end, entry;
76 77
	static struct acpi_table_madt *madt;
	static int read_madt;
78 79
	int apic_id = -1;

80 81 82 83 84 85 86
	if (!read_madt) {
		if (ACPI_FAILURE(acpi_get_table(ACPI_SIG_MADT, 0,
					(struct acpi_table_header **)&madt)))
			madt = NULL;
		read_madt++;
	}

87 88 89 90 91 92 93 94 95 96 97 98 99
	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) {
		struct acpi_subtable_header *header =
			(struct acpi_subtable_header *)entry;
		if (header->type == ACPI_MADT_TYPE_LOCAL_APIC) {
100
			if (!map_lapic_id(header, acpi_id, &apic_id))
101 102
				break;
		} else if (header->type == ACPI_MADT_TYPE_LOCAL_X2APIC) {
103
			if (!map_x2apic_id(header, type, acpi_id, &apic_id))
104 105
				break;
		} else if (header->type == ACPI_MADT_TYPE_LOCAL_SAPIC) {
106
			if (!map_lsapic_id(header, type, acpi_id, &apic_id))
107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140
				break;
		}
		entry += header->length;
	}
	return apic_id;
}

static int 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;
	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_LOCAL_APIC) {
		map_lapic_id(header, acpi_id, &apic_id);
	} else if (header->type == ACPI_MADT_TYPE_LOCAL_SAPIC) {
		map_lsapic_id(header, type, acpi_id, &apic_id);
	}

exit:
141
	kfree(buffer.pointer);
142 143 144
	return apic_id;
}

145
int acpi_get_apicid(acpi_handle handle, int type, u32 acpi_id)
146
{
147
	int apic_id;
148 149 150 151

	apic_id = map_mat_entry(handle, type, acpi_id);
	if (apic_id == -1)
		apic_id = map_madt_entry(type, acpi_id);
152 153 154 155 156 157 158 159 160 161

	return apic_id;
}

int acpi_map_cpuid(int apic_id, u32 acpi_id)
{
#ifdef CONFIG_SMP
	int i;
#endif

162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177
	if (apic_id == -1) {
		/*
		 * On UP processor, there is no _MAT or MADT table.
		 * So above apic_id is always set to -1.
		 *
		 * 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) {}
		 * }
		 *
178 179 180
		 * Ignores apic_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.
181 182
		 * Return -1 for other CPU's handle.
		 */
183
		if (nr_cpu_ids <= 1 && acpi_id == 0)
184 185 186 187
			return acpi_id;
		else
			return apic_id;
	}
188

189
#ifdef CONFIG_SMP
190 191 192 193
	for_each_possible_cpu(i) {
		if (cpu_physical_id(i) == apic_id)
			return i;
	}
194 195 196 197 198
#else
	/* In UP kernel, only processor 0 is valid */
	if (apic_id == 0)
		return apic_id;
#endif
199 200
	return -1;
}
201 202 203 204 205 206 207 208 209

int acpi_get_cpuid(acpi_handle handle, int type, u32 acpi_id)
{
	int apic_id;

	apic_id = acpi_get_apicid(handle, type, acpi_id);

	return acpi_map_cpuid(apic_id, acpi_id);
}
210 211
EXPORT_SYMBOL_GPL(acpi_get_cpuid);

212
static bool __init processor_physically_present(acpi_handle handle)
213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245
{
	int cpuid, type;
	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;
		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;
	cpuid = acpi_get_cpuid(handle, type, acpi_id);

246
	if (cpuid == -1)
247 248 249 250
		return false;

	return true;
}
251

252
static void acpi_set_pdc_bits(u32 *buf)
253 254 255 256 257 258
{
	buf[0] = ACPI_PDC_REVISION_ID;
	buf[1] = 1;

	/* Enable coordination with firmware's _TSD info */
	buf[2] = ACPI_PDC_SMP_T_SWCOORD;
259 260 261

	/* Twiddle arch-specific bits needed for _PDC */
	arch_acpi_set_pdc_bits(buf);
262 263
}

264
static struct acpi_object_list *acpi_processor_alloc_pdc(void)
265 266 267 268 269 270 271 272 273
{
	struct acpi_object_list *obj_list;
	union acpi_object *obj;
	u32 *buf;

	/* allocate and initialize pdc. It will be used later. */
	obj_list = kmalloc(sizeof(struct acpi_object_list), GFP_KERNEL);
	if (!obj_list) {
		printk(KERN_ERR "Memory allocation error\n");
274
		return NULL;
275 276 277 278 279 280
	}

	obj = kmalloc(sizeof(union acpi_object), GFP_KERNEL);
	if (!obj) {
		printk(KERN_ERR "Memory allocation error\n");
		kfree(obj_list);
281
		return NULL;
282 283 284 285 286 287 288
	}

	buf = kmalloc(12, GFP_KERNEL);
	if (!buf) {
		printk(KERN_ERR "Memory allocation error\n");
		kfree(obj);
		kfree(obj_list);
289
		return NULL;
290 291
	}

292 293
	acpi_set_pdc_bits(buf);

294 295 296 297 298 299
	obj->type = ACPI_TYPE_BUFFER;
	obj->buffer.length = 12;
	obj->buffer.pointer = (u8 *) buf;
	obj_list->count = 1;
	obj_list->pointer = obj;

300
	return obj_list;
301 302
}

A
Alex Chiang 已提交
303 304 305 306
/*
 * _PDC is required for a BIOS-OS handshake for most of the newer
 * ACPI processor features.
 */
307
static acpi_status
308
acpi_processor_eval_pdc(acpi_handle handle, struct acpi_object_list *pdc_in)
A
Alex Chiang 已提交
309 310 311
{
	acpi_status status = AE_OK;

312
	if (boot_option_idle_override == IDLE_NOMWAIT) {
A
Alex Chiang 已提交
313 314 315 316 317 318 319 320 321 322 323 324 325
		/*
		 * If mwait is disabled for CPU C-states, the C2C3_FFH access
		 * mode will be disabled in the parameter of _PDC object.
		 * Of course C1_FFH access mode will also be disabled.
		 */
		union acpi_object *obj;
		u32 *buffer = NULL;

		obj = pdc_in->pointer;
		buffer = (u32 *)(obj->buffer.pointer);
		buffer[2] &= ~(ACPI_PDC_C_C2C3_FFH | ACPI_PDC_C_C1_FFH);

	}
326
	status = acpi_evaluate_object(handle, "_PDC", pdc_in, NULL);
A
Alex Chiang 已提交
327 328 329 330 331 332 333 334

	if (ACPI_FAILURE(status))
		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
		    "Could not evaluate _PDC, using legacy perf. control.\n"));

	return status;
}

335
void acpi_processor_set_pdc(acpi_handle handle)
A
Alex Chiang 已提交
336
{
337 338
	struct acpi_object_list *obj_list;

339 340 341
	if (arch_has_acpi_pdc() == false)
		return;

342 343 344 345
	obj_list = acpi_processor_alloc_pdc();
	if (!obj_list)
		return;

346
	acpi_processor_eval_pdc(handle, obj_list);
347 348 349 350

	kfree(obj_list->pointer->buffer.pointer);
	kfree(obj_list->pointer);
	kfree(obj_list);
A
Alex Chiang 已提交
351 352
}

353
static acpi_status __init
A
Alex Chiang 已提交
354 355
early_init_pdc(acpi_handle handle, u32 lvl, void *context, void **rv)
{
356 357 358
	if (processor_physically_present(handle) == false)
		return AE_OK;

359
	acpi_processor_set_pdc(handle);
A
Alex Chiang 已提交
360 361 362
	return AE_OK;
}

363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382
#if defined(CONFIG_X86) || defined(CONFIG_IA64)
static int __init set_no_mwait(const struct dmi_system_id *id)
{
	pr_notice(PREFIX "%s detected - disabling mwait for CPU C-states\n",
		  id->ident);
	boot_option_idle_override = IDLE_NOMWAIT;
	return 0;
}

static struct dmi_system_id processor_idle_dmi_table[] __initdata = {
	{
	set_no_mwait, "Extensa 5220", {
	DMI_MATCH(DMI_BIOS_VENDOR, "Phoenix Technologies LTD"),
	DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
	DMI_MATCH(DMI_PRODUCT_VERSION, "0100"),
	DMI_MATCH(DMI_BOARD_NAME, "Columbia") }, NULL},
	{},
};

static void __init processor_dmi_check(void)
A
Alex Chiang 已提交
383 384 385 386 387 388
{
	/*
	 * Check whether the system is DMI table. If yes, OSPM
	 * should not use mwait for CPU-states.
	 */
	dmi_check_system(processor_idle_dmi_table);
389 390 391 392 393 394 395 396
}
#else
static inline void processor_dmi_check(void) {}
#endif

void __init acpi_early_processor_set_pdc(void)
{
	processor_dmi_check();
A
Alex Chiang 已提交
397 398 399 400

	acpi_walk_namespace(ACPI_TYPE_PROCESSOR, ACPI_ROOT_OBJECT,
			    ACPI_UINT32_MAX,
			    early_init_pdc, NULL, NULL, NULL);
401
	acpi_get_devices(ACPI_PROCESSOR_DEVICE_HID, early_init_pdc, NULL, NULL);
A
Alex Chiang 已提交
402
}