processor_core.c 27.1 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68
/*
 * acpi_processor.c - ACPI Processor Driver ($Revision: 71 $)
 *
 *  Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
 *  Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
 *  Copyright (C) 2004       Dominik Brodowski <linux@brodo.de>
 *  Copyright (C) 2004  Anil S Keshavamurthy <anil.s.keshavamurthy@intel.com>
 *  			- Added processor hotplug support
 *
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or (at
 *  your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful, but
 *  WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *  General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License along
 *  with this program; if not, write to the Free Software Foundation, Inc.,
 *  59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
 *
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 *  TBD:
 *	1. Make # power states dynamic.
 *	2. Support duty_cycle values that span bit 4.
 *	3. Optimize by having scheduler determine business instead of
 *	   having us try to calculate it here.
 *	4. Need C1 timing -- must modify kernel (IRQ handler) to get this.
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/types.h>
#include <linux/pci.h>
#include <linux/pm.h>
#include <linux/cpufreq.h>
#include <linux/cpu.h>
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
#include <linux/dmi.h>
#include <linux/moduleparam.h>

#include <asm/io.h>
#include <asm/system.h>
#include <asm/cpu.h>
#include <asm/delay.h>
#include <asm/uaccess.h>
#include <asm/processor.h>
#include <asm/smp.h>
#include <asm/acpi.h>

#include <acpi/acpi_bus.h>
#include <acpi/acpi_drivers.h>
#include <acpi/processor.h>

#define ACPI_PROCESSOR_COMPONENT	0x01000000
#define ACPI_PROCESSOR_CLASS		"processor"
#define ACPI_PROCESSOR_DEVICE_NAME	"Processor"
#define ACPI_PROCESSOR_FILE_INFO	"info"
#define ACPI_PROCESSOR_FILE_THROTTLING	"throttling"
#define ACPI_PROCESSOR_FILE_LIMIT	"limit"
#define ACPI_PROCESSOR_NOTIFY_PERFORMANCE 0x80
#define ACPI_PROCESSOR_NOTIFY_POWER	0x81
69
#define ACPI_PROCESSOR_NOTIFY_THROTTLING	0x82
L
Linus Torvalds 已提交
70 71 72 73 74

#define ACPI_PROCESSOR_LIMIT_USER	0
#define ACPI_PROCESSOR_LIMIT_THERMAL	1

#define _COMPONENT		ACPI_PROCESSOR_COMPONENT
75
ACPI_MODULE_NAME("processor_core");
L
Linus Torvalds 已提交
76

77
MODULE_AUTHOR("Paul Diefenbaugh");
78
MODULE_DESCRIPTION("ACPI Processor Driver");
L
Linus Torvalds 已提交
79 80
MODULE_LICENSE("GPL");

L
Len Brown 已提交
81 82 83
static int acpi_processor_add(struct acpi_device *device);
static int acpi_processor_start(struct acpi_device *device);
static int acpi_processor_remove(struct acpi_device *device, int type);
L
Linus Torvalds 已提交
84
static int acpi_processor_info_open_fs(struct inode *inode, struct file *file);
L
Len Brown 已提交
85
static void acpi_processor_notify(acpi_handle handle, u32 event, void *data);
L
Linus Torvalds 已提交
86 87
static acpi_status acpi_processor_hotadd_init(acpi_handle handle, int *p_cpu);
static int acpi_processor_handle_eject(struct acpi_processor *pr);
88 89
extern int acpi_processor_tstate_has_changed(struct acpi_processor *pr);

L
Linus Torvalds 已提交
90

91 92 93 94 95 96
static const struct acpi_device_id processor_device_ids[] = {
	{ACPI_PROCESSOR_HID, 0},
	{"", 0},
};
MODULE_DEVICE_TABLE(acpi, processor_device_ids);

L
Linus Torvalds 已提交
97
static struct acpi_driver acpi_processor_driver = {
L
Len Brown 已提交
98
	.name = "processor",
L
Len Brown 已提交
99
	.class = ACPI_PROCESSOR_CLASS,
100
	.ids = processor_device_ids,
L
Len Brown 已提交
101 102 103 104
	.ops = {
		.add = acpi_processor_add,
		.remove = acpi_processor_remove,
		.start = acpi_processor_start,
105 106
		.suspend = acpi_processor_suspend,
		.resume = acpi_processor_resume,
L
Len Brown 已提交
107
		},
L
Linus Torvalds 已提交
108 109 110 111 112
};

#define INSTALL_NOTIFY_HANDLER		1
#define UNINSTALL_NOTIFY_HANDLER	2

113
static const struct file_operations acpi_processor_info_fops = {
L
Len Brown 已提交
114 115 116 117
	.open = acpi_processor_info_open_fs,
	.read = seq_read,
	.llseek = seq_lseek,
	.release = single_release,
L
Linus Torvalds 已提交
118 119
};

L
Len Brown 已提交
120
struct acpi_processor *processors[NR_CPUS];
121
struct acpi_processor_errata errata __read_mostly;
L
Linus Torvalds 已提交
122 123 124 125 126

/* --------------------------------------------------------------------------
                                Errata Handling
   -------------------------------------------------------------------------- */

L
Len Brown 已提交
127
static int acpi_processor_errata_piix4(struct pci_dev *dev)
L
Linus Torvalds 已提交
128
{
L
Len Brown 已提交
129 130
	u8 value1 = 0;
	u8 value2 = 0;
L
Linus Torvalds 已提交
131 132 133


	if (!dev)
134
		return -EINVAL;
L
Linus Torvalds 已提交
135 136 137 138 139

	/*
	 * Note that 'dev' references the PIIX4 ACPI Controller.
	 */

140
	switch (dev->revision) {
L
Linus Torvalds 已提交
141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157
	case 0:
		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found PIIX4 A-step\n"));
		break;
	case 1:
		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found PIIX4 B-step\n"));
		break;
	case 2:
		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found PIIX4E\n"));
		break;
	case 3:
		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found PIIX4M\n"));
		break;
	default:
		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found unknown PIIX4\n"));
		break;
	}

158
	switch (dev->revision) {
L
Linus Torvalds 已提交
159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187

	case 0:		/* PIIX4 A-step */
	case 1:		/* PIIX4 B-step */
		/*
		 * See specification changes #13 ("Manual Throttle Duty Cycle")
		 * and #14 ("Enabling and Disabling Manual Throttle"), plus
		 * erratum #5 ("STPCLK# Deassertion Time") from the January
		 * 2002 PIIX4 specification update.  Applies to only older
		 * PIIX4 models.
		 */
		errata.piix4.throttle = 1;

	case 2:		/* PIIX4E */
	case 3:		/* PIIX4M */
		/*
		 * See erratum #18 ("C3 Power State/BMIDE and Type-F DMA
		 * Livelock") from the January 2002 PIIX4 specification update.
		 * Applies to all PIIX4 models.
		 */

		/*
		 * BM-IDE
		 * ------
		 * Find the PIIX4 IDE Controller and get the Bus Master IDE
		 * Status register address.  We'll use this later to read
		 * each IDE controller's DMA status to make sure we catch all
		 * DMA activity.
		 */
		dev = pci_get_subsys(PCI_VENDOR_ID_INTEL,
L
Len Brown 已提交
188 189
				     PCI_DEVICE_ID_INTEL_82371AB,
				     PCI_ANY_ID, PCI_ANY_ID, NULL);
L
Linus Torvalds 已提交
190 191 192 193 194 195 196 197 198 199 200 201 202 203 204
		if (dev) {
			errata.piix4.bmisx = pci_resource_start(dev, 4);
			pci_dev_put(dev);
		}

		/*
		 * Type-F DMA
		 * ----------
		 * Find the PIIX4 ISA Controller and read the Motherboard
		 * DMA controller's status to see if Type-F (Fast) DMA mode
		 * is enabled (bit 7) on either channel.  Note that we'll
		 * disable C3 support if this is enabled, as some legacy
		 * devices won't operate well if fast DMA is disabled.
		 */
		dev = pci_get_subsys(PCI_VENDOR_ID_INTEL,
L
Len Brown 已提交
205 206
				     PCI_DEVICE_ID_INTEL_82371AB_0,
				     PCI_ANY_ID, PCI_ANY_ID, NULL);
L
Linus Torvalds 已提交
207 208 209 210 211 212 213 214 215 216 217 218 219
		if (dev) {
			pci_read_config_byte(dev, 0x76, &value1);
			pci_read_config_byte(dev, 0x77, &value2);
			if ((value1 & 0x80) || (value2 & 0x80))
				errata.piix4.fdma = 1;
			pci_dev_put(dev);
		}

		break;
	}

	if (errata.piix4.bmisx)
		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
L
Len Brown 已提交
220
				  "Bus master activity detection (BM-IDE) erratum enabled\n"));
L
Linus Torvalds 已提交
221 222
	if (errata.piix4.fdma)
		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
L
Len Brown 已提交
223
				  "Type-F DMA livelock erratum (C3 disabled)\n"));
L
Linus Torvalds 已提交
224

225
	return 0;
L
Linus Torvalds 已提交
226 227
}

228
static int acpi_processor_errata(struct acpi_processor *pr)
L
Linus Torvalds 已提交
229
{
L
Len Brown 已提交
230 231
	int result = 0;
	struct pci_dev *dev = NULL;
L
Linus Torvalds 已提交
232 233 234


	if (!pr)
235
		return -EINVAL;
L
Linus Torvalds 已提交
236 237 238 239 240

	/*
	 * PIIX4
	 */
	dev = pci_get_subsys(PCI_VENDOR_ID_INTEL,
L
Len Brown 已提交
241 242
			     PCI_DEVICE_ID_INTEL_82371AB_3, PCI_ANY_ID,
			     PCI_ANY_ID, NULL);
L
Linus Torvalds 已提交
243 244 245 246 247
	if (dev) {
		result = acpi_processor_errata_piix4(dev);
		pci_dev_put(dev);
	}

248
	return result;
L
Linus Torvalds 已提交
249 250
}

251
/* --------------------------------------------------------------------------
252
                              Common ACPI processor functions
253 254 255 256 257 258
   -------------------------------------------------------------------------- */

/*
 * _PDC is required for a BIOS-OS handshake for most of the newer
 * ACPI processor features.
 */
259
static int acpi_processor_set_pdc(struct acpi_processor *pr)
260
{
261
	struct acpi_object_list *pdc_in = pr->pdc;
L
Len Brown 已提交
262
	acpi_status status = AE_OK;
263 264


265
	if (!pdc_in)
266
		return status;
267

268
	status = acpi_evaluate_object(pr->handle, "_PDC", pdc_in, NULL);
269

270
	if (ACPI_FAILURE(status))
L
Len Brown 已提交
271
		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
272
		    "Could not evaluate _PDC, using legacy perf. control...\n"));
273

274
	return status;
275 276
}

L
Linus Torvalds 已提交
277 278 279 280
/* --------------------------------------------------------------------------
                              FS Interface (/proc)
   -------------------------------------------------------------------------- */

L
Len Brown 已提交
281
static struct proc_dir_entry *acpi_processor_dir = NULL;
L
Linus Torvalds 已提交
282 283 284

static int acpi_processor_info_seq_show(struct seq_file *seq, void *offset)
{
285
	struct acpi_processor *pr = seq->private;
L
Linus Torvalds 已提交
286 287 288 289 290 291


	if (!pr)
		goto end;

	seq_printf(seq, "processor id:            %d\n"
L
Len Brown 已提交
292 293 294 295 296 297 298 299 300 301 302 303 304
		   "acpi id:                 %d\n"
		   "bus mastering control:   %s\n"
		   "power management:        %s\n"
		   "throttling control:      %s\n"
		   "limit interface:         %s\n",
		   pr->id,
		   pr->acpi_id,
		   pr->flags.bm_control ? "yes" : "no",
		   pr->flags.power ? "yes" : "no",
		   pr->flags.throttling ? "yes" : "no",
		   pr->flags.limit ? "yes" : "no");

      end:
305
	return 0;
L
Linus Torvalds 已提交
306 307 308 309 310
}

static int acpi_processor_info_open_fs(struct inode *inode, struct file *file)
{
	return single_open(file, acpi_processor_info_seq_show,
L
Len Brown 已提交
311
			   PDE(inode)->data);
L
Linus Torvalds 已提交
312 313
}

L
Len Brown 已提交
314
static int acpi_processor_add_fs(struct acpi_device *device)
L
Linus Torvalds 已提交
315
{
L
Len Brown 已提交
316
	struct proc_dir_entry *entry = NULL;
L
Linus Torvalds 已提交
317 318 319 320


	if (!acpi_device_dir(device)) {
		acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device),
L
Len Brown 已提交
321
						     acpi_processor_dir);
L
Linus Torvalds 已提交
322
		if (!acpi_device_dir(device))
323
			return -ENODEV;
L
Linus Torvalds 已提交
324 325 326 327 328
	}
	acpi_device_dir(device)->owner = THIS_MODULE;

	/* 'info' [R] */
	entry = create_proc_entry(ACPI_PROCESSOR_FILE_INFO,
L
Len Brown 已提交
329
				  S_IRUGO, acpi_device_dir(device));
L
Linus Torvalds 已提交
330
	if (!entry)
331
		return -EIO;
L
Linus Torvalds 已提交
332 333 334 335 336 337 338 339
	else {
		entry->proc_fops = &acpi_processor_info_fops;
		entry->data = acpi_driver_data(device);
		entry->owner = THIS_MODULE;
	}

	/* 'throttling' [R/W] */
	entry = create_proc_entry(ACPI_PROCESSOR_FILE_THROTTLING,
L
Len Brown 已提交
340 341
				  S_IFREG | S_IRUGO | S_IWUSR,
				  acpi_device_dir(device));
L
Linus Torvalds 已提交
342
	if (!entry)
343
		return -EIO;
L
Linus Torvalds 已提交
344 345 346 347 348 349 350 351
	else {
		entry->proc_fops = &acpi_processor_throttling_fops;
		entry->data = acpi_driver_data(device);
		entry->owner = THIS_MODULE;
	}

	/* 'limit' [R/W] */
	entry = create_proc_entry(ACPI_PROCESSOR_FILE_LIMIT,
L
Len Brown 已提交
352 353
				  S_IFREG | S_IRUGO | S_IWUSR,
				  acpi_device_dir(device));
L
Linus Torvalds 已提交
354
	if (!entry)
355
		return -EIO;
L
Linus Torvalds 已提交
356 357 358 359 360 361
	else {
		entry->proc_fops = &acpi_processor_limit_fops;
		entry->data = acpi_driver_data(device);
		entry->owner = THIS_MODULE;
	}

362
	return 0;
L
Linus Torvalds 已提交
363 364
}

L
Len Brown 已提交
365
static int acpi_processor_remove_fs(struct acpi_device *device)
L
Linus Torvalds 已提交
366 367 368
{

	if (acpi_device_dir(device)) {
L
Len Brown 已提交
369 370
		remove_proc_entry(ACPI_PROCESSOR_FILE_INFO,
				  acpi_device_dir(device));
L
Linus Torvalds 已提交
371
		remove_proc_entry(ACPI_PROCESSOR_FILE_THROTTLING,
L
Len Brown 已提交
372 373 374
				  acpi_device_dir(device));
		remove_proc_entry(ACPI_PROCESSOR_FILE_LIMIT,
				  acpi_device_dir(device));
L
Linus Torvalds 已提交
375 376 377 378
		remove_proc_entry(acpi_device_bid(device), acpi_processor_dir);
		acpi_device_dir(device) = NULL;
	}

379
	return 0;
L
Linus Torvalds 已提交
380 381 382
}

/* Use the acpiid in MADT to map cpus in case of SMP */
383

L
Linus Torvalds 已提交
384
#ifndef CONFIG_SMP
385
static int get_cpu_id(acpi_handle handle, u32 acpi_id) {return -1;}
L
Linus Torvalds 已提交
386 387
#else

388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411
static struct acpi_table_madt *madt;

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;
	if ((lapic->lapic_flags & ACPI_MADT_ENABLED) &&
	    lapic->processor_id == acpi_id) {
		*apic_id = lapic->id;
		return 1;
	}
	return 0;
}

static int map_lsapic_id(struct acpi_subtable_header *entry,
		  u32 acpi_id, int *apic_id)
{
	struct acpi_madt_local_sapic *lsapic =
		(struct acpi_madt_local_sapic *)entry;
	/* Only check enabled APICs*/
	if (lsapic->lapic_flags & ACPI_MADT_ENABLED) {
		/* First check against id */
		if (lsapic->processor_id == acpi_id) {
412
			*apic_id = (lsapic->id << 8) | lsapic->eid;
413 414 415 416 417 418 419 420 421 422 423
			return 1;
		/* Check against optional uid */
		} else if (entry->length >= 16 &&
			lsapic->uid == acpi_id) {
			*apic_id = lsapic->uid;
			return 1;
		}
	}
	return 0;
}

L
Linus Torvalds 已提交
424 425 426 427 428 429
#ifdef CONFIG_IA64
#define arch_cpu_to_apicid 	ia64_cpu_to_sapicid
#else
#define arch_cpu_to_apicid 	x86_cpu_to_apicid
#endif

430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490
static int map_madt_entry(u32 acpi_id)
{
	unsigned long madt_end, entry;
	int apic_id = -1;

	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) {
			if (map_lapic_id(header, acpi_id, &apic_id))
				break;
		} else if (header->type == ACPI_MADT_TYPE_LOCAL_SAPIC) {
			if (map_lsapic_id(header, acpi_id, &apic_id))
				break;
		}
		entry += header->length;
	}
	return apic_id;
}

static int map_mat_entry(acpi_handle handle, 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, acpi_id, &apic_id);
	}

exit:
	if (buffer.pointer)
		kfree(buffer.pointer);
	return apic_id;
}

491
static int get_cpu_id(acpi_handle handle, u32 acpi_id)
L
Linus Torvalds 已提交
492
{
493
	int i;
494
	int apic_id = -1;
L
Linus Torvalds 已提交
495

496 497 498 499 500
	apic_id = map_mat_entry(handle, acpi_id);
	if (apic_id == -1)
		apic_id = map_madt_entry(acpi_id);
	if (apic_id == -1)
		return apic_id;
L
Linus Torvalds 已提交
501

502
	for (i = 0; i < NR_CPUS; ++i) {
503 504
		if (arch_cpu_to_apicid[i] == apic_id)
			return i;
L
Linus Torvalds 已提交
505 506 507 508 509 510 511 512 513
	}
	return -1;
}
#endif

/* --------------------------------------------------------------------------
                                 Driver Interface
   -------------------------------------------------------------------------- */

514
static int acpi_processor_get_info(struct acpi_processor *pr, unsigned has_uid)
L
Linus Torvalds 已提交
515
{
L
Len Brown 已提交
516 517 518
	acpi_status status = 0;
	union acpi_object object = { 0 };
	struct acpi_buffer buffer = { sizeof(union acpi_object), &object };
A
Ashok Raj 已提交
519
	int cpu_index;
L
Len Brown 已提交
520
	static int cpu0_initialized;
L
Linus Torvalds 已提交
521 522 523


	if (!pr)
524
		return -EINVAL;
L
Linus Torvalds 已提交
525 526 527 528 529 530 531 532 533 534

	if (num_online_cpus() > 1)
		errata.smp = TRUE;

	acpi_processor_errata(pr);

	/*
	 * Check to see if we have bus mastering arbitration control.  This
	 * is required for proper C3 usage (to maintain cache coherency).
	 */
535
	if (acpi_gbl_FADT.pm2_control_block && acpi_gbl_FADT.pm2_control_length) {
L
Linus Torvalds 已提交
536 537
		pr->flags.bm_control = 1;
		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
L
Len Brown 已提交
538 539
				  "Bus mastering arbitration control present\n"));
	} else
L
Linus Torvalds 已提交
540
		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
L
Len Brown 已提交
541
				  "No bus mastering arbitration control\n"));
L
Linus Torvalds 已提交
542

543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563
	/* Check if it is a Device with HID and UID */
	if (has_uid) {
		unsigned long value;
		status = acpi_evaluate_integer(pr->handle, METHOD_NAME__UID,
						NULL, &value);
		if (ACPI_FAILURE(status)) {
			printk(KERN_ERR PREFIX "Evaluating processor _UID\n");
			return -ENODEV;
		}
		pr->acpi_id = value;
	} else {
		/*
		* Evalute the processor object.  Note that it is common on SMP to
		* have the first (boot) processor with a valid PBLK address while
		* all others have a NULL address.
		*/
		status = acpi_evaluate_object(pr->handle, NULL, NULL, &buffer);
		if (ACPI_FAILURE(status)) {
			printk(KERN_ERR PREFIX "Evaluating processor object\n");
			return -ENODEV;
		}
L
Linus Torvalds 已提交
564

565 566 567 568 569 570 571
		/*
		* TBD: Synch processor ID (via LAPIC/LSAPIC structures) on SMP.
		*      >>> 'acpi_get_processor_id(acpi_id, &id)' in arch/xxx/acpi.c
		*/
		pr->acpi_id = object.processor.proc_id;
	}
	cpu_index = get_cpu_id(pr->handle, pr->acpi_id);
L
Linus Torvalds 已提交
572

L
Len Brown 已提交
573
	/* Handle UP system running SMP kernel, with no LAPIC in MADT */
A
Ashok Raj 已提交
574
	if (!cpu0_initialized && (cpu_index == -1) &&
L
Len Brown 已提交
575 576 577 578 579 580 581 582 583 584 585 586 587
	    (num_online_cpus() == 1)) {
		cpu_index = 0;
	}

	cpu0_initialized = 1;

	pr->id = cpu_index;

	/*
	 *  Extra Processor objects may be enumerated on MP systems with
	 *  less than the max # of CPUs. They should be ignored _iff
	 *  they are physically not present.
	 */
588
	if (pr->id == -1) {
L
Len Brown 已提交
589 590
		if (ACPI_FAILURE
		    (acpi_processor_hotadd_init(pr->handle, &pr->id))) {
591
			return -ENODEV;
L
Len Brown 已提交
592 593
		}
	}
L
Linus Torvalds 已提交
594 595

	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Processor [%d:%d]\n", pr->id,
L
Len Brown 已提交
596
			  pr->acpi_id));
L
Linus Torvalds 已提交
597 598 599 600

	if (!object.processor.pblk_address)
		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No PBLK (NULL address)\n"));
	else if (object.processor.pblk_length != 6)
601 602
		printk(KERN_ERR PREFIX "Invalid PBLK length [%d]\n",
			    object.processor.pblk_length);
L
Linus Torvalds 已提交
603 604
	else {
		pr->throttling.address = object.processor.pblk_address;
605 606
		pr->throttling.duty_offset = acpi_gbl_FADT.duty_offset;
		pr->throttling.duty_width = acpi_gbl_FADT.duty_width;
L
Linus Torvalds 已提交
607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625

		pr->pblk = object.processor.pblk_address;

		/*
		 * We don't care about error returns - we just try to mark
		 * these reserved so that nobody else is confused into thinking
		 * that this region might be unused..
		 *
		 * (In particular, allocating the IO range for Cardbus)
		 */
		request_region(pr->throttling.address, 6, "ACPI CPU throttle");
	}

#ifdef CONFIG_CPU_FREQ
	acpi_processor_ppc_has_changed(pr);
#endif
	acpi_processor_get_throttling_info(pr);
	acpi_processor_get_limit_info(pr);

626
	return 0;
L
Linus Torvalds 已提交
627 628
}

629 630
static void *processor_device_array[NR_CPUS];

631
static int __cpuinit acpi_processor_start(struct acpi_device *device)
L
Linus Torvalds 已提交
632
{
L
Len Brown 已提交
633 634 635
	int result = 0;
	acpi_status status = AE_OK;
	struct acpi_processor *pr;
L
Linus Torvalds 已提交
636 637 638 639


	pr = acpi_driver_data(device);

640
	result = acpi_processor_get_info(pr, device->flags.unique_id);
L
Linus Torvalds 已提交
641 642
	if (result) {
		/* Processor is physically not present */
643
		return 0;
L
Linus Torvalds 已提交
644 645 646 647
	}

	BUG_ON((pr->id >= NR_CPUS) || (pr->id < 0));

648 649 650 651 652 653
	/*
	 * Buggy BIOS check
	 * ACPI id of processors can be reported wrongly by the BIOS.
	 * Don't trust it blindly
	 */
	if (processor_device_array[pr->id] != NULL &&
654
	    processor_device_array[pr->id] != device) {
L
Len Brown 已提交
655 656
		printk(KERN_WARNING "BIOS reported wrong ACPI id"
			"for the processor\n");
657
		return -ENODEV;
658
	}
659
	processor_device_array[pr->id] = device;
660

L
Linus Torvalds 已提交
661 662 663 664 665 666 667
	processors[pr->id] = pr;

	result = acpi_processor_add_fs(device);
	if (result)
		goto end;

	status = acpi_install_notify_handler(pr->handle, ACPI_DEVICE_NOTIFY,
L
Len Brown 已提交
668
					     acpi_processor_notify, pr);
L
Linus Torvalds 已提交
669

670 671 672 673
	/* _PDC call should be done before doing anything else (if reqd.). */
	arch_acpi_processor_init_pdc(pr);
	acpi_processor_set_pdc(pr);

L
Linus Torvalds 已提交
674 675 676 677
	acpi_processor_power_init(pr, device);

	if (pr->flags.throttling) {
		printk(KERN_INFO PREFIX "%s [%s] (supports",
L
Len Brown 已提交
678
		       acpi_device_name(device), acpi_device_bid(device));
L
Linus Torvalds 已提交
679 680 681 682
		printk(" %d throttling states", pr->throttling.state_count);
		printk(")\n");
	}

L
Len Brown 已提交
683
      end:
L
Linus Torvalds 已提交
684

685
	return result;
L
Linus Torvalds 已提交
686 687
}

L
Len Brown 已提交
688
static void acpi_processor_notify(acpi_handle handle, u32 event, void *data)
L
Linus Torvalds 已提交
689
{
690
	struct acpi_processor *pr = data;
L
Len Brown 已提交
691
	struct acpi_device *device = NULL;
L
Linus Torvalds 已提交
692 693 694


	if (!pr)
695
		return;
L
Linus Torvalds 已提交
696 697

	if (acpi_bus_get_device(pr->handle, &device))
698
		return;
L
Linus Torvalds 已提交
699 700 701 702

	switch (event) {
	case ACPI_PROCESSOR_NOTIFY_PERFORMANCE:
		acpi_processor_ppc_has_changed(pr);
703
		acpi_bus_generate_proc_event(device, event,
L
Len Brown 已提交
704
					pr->performance_platform_limit);
705 706 707
		acpi_bus_generate_netlink_event(device->pnp.device_class,
						  device->dev.bus_id, event,
						  pr->performance_platform_limit);
L
Linus Torvalds 已提交
708 709 710
		break;
	case ACPI_PROCESSOR_NOTIFY_POWER:
		acpi_processor_cst_has_changed(pr);
711
		acpi_bus_generate_proc_event(device, event, 0);
712 713
		acpi_bus_generate_netlink_event(device->pnp.device_class,
						  device->dev.bus_id, event, 0);
L
Linus Torvalds 已提交
714
		break;
715 716
	case ACPI_PROCESSOR_NOTIFY_THROTTLING:
		acpi_processor_tstate_has_changed(pr);
717
		acpi_bus_generate_proc_event(device, event, 0);
718 719
		acpi_bus_generate_netlink_event(device->pnp.device_class,
						  device->dev.bus_id, event, 0);
L
Linus Torvalds 已提交
720 721
	default:
		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
L
Len Brown 已提交
722
				  "Unsupported event [0x%x]\n", event));
L
Linus Torvalds 已提交
723 724 725
		break;
	}

726
	return;
L
Linus Torvalds 已提交
727 728
}

729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747
static int acpi_cpu_soft_notify(struct notifier_block *nfb,
		unsigned long action, void *hcpu)
{
	unsigned int cpu = (unsigned long)hcpu;
	struct acpi_processor *pr = processors[cpu];

	if (action == CPU_ONLINE && pr) {
		acpi_processor_ppc_has_changed(pr);
		acpi_processor_cst_has_changed(pr);
		acpi_processor_tstate_has_changed(pr);
	}
	return NOTIFY_OK;
}

static struct notifier_block acpi_cpu_notifier =
{
	    .notifier_call = acpi_cpu_soft_notify,
};

L
Len Brown 已提交
748
static int acpi_processor_add(struct acpi_device *device)
L
Linus Torvalds 已提交
749
{
L
Len Brown 已提交
750
	struct acpi_processor *pr = NULL;
L
Linus Torvalds 已提交
751 752 753


	if (!device)
754
		return -EINVAL;
L
Linus Torvalds 已提交
755

756
	pr = kzalloc(sizeof(struct acpi_processor), GFP_KERNEL);
L
Linus Torvalds 已提交
757
	if (!pr)
758
		return -ENOMEM;
L
Linus Torvalds 已提交
759 760 761 762 763 764

	pr->handle = device->handle;
	strcpy(acpi_device_name(device), ACPI_PROCESSOR_DEVICE_NAME);
	strcpy(acpi_device_class(device), ACPI_PROCESSOR_CLASS);
	acpi_driver_data(device) = pr;

765
	return 0;
L
Linus Torvalds 已提交
766 767
}

L
Len Brown 已提交
768
static int acpi_processor_remove(struct acpi_device *device, int type)
L
Linus Torvalds 已提交
769
{
L
Len Brown 已提交
770 771
	acpi_status status = AE_OK;
	struct acpi_processor *pr = NULL;
L
Linus Torvalds 已提交
772 773 774


	if (!device || !acpi_driver_data(device))
775
		return -EINVAL;
L
Linus Torvalds 已提交
776

777
	pr = acpi_driver_data(device);
L
Linus Torvalds 已提交
778 779 780

	if (pr->id >= NR_CPUS) {
		kfree(pr);
781
		return 0;
L
Linus Torvalds 已提交
782 783 784 785
	}

	if (type == ACPI_BUS_REMOVAL_EJECT) {
		if (acpi_processor_handle_eject(pr))
786
			return -EINVAL;
L
Linus Torvalds 已提交
787 788 789 790 791
	}

	acpi_processor_power_exit(pr, device);

	status = acpi_remove_notify_handler(pr->handle, ACPI_DEVICE_NOTIFY,
L
Len Brown 已提交
792
					    acpi_processor_notify);
L
Linus Torvalds 已提交
793 794 795 796 797 798 799

	acpi_processor_remove_fs(device);

	processors[pr->id] = NULL;

	kfree(pr);

800
	return 0;
L
Linus Torvalds 已提交
801 802 803 804 805 806 807 808 809
}

#ifdef CONFIG_ACPI_HOTPLUG_CPU
/****************************************************************************
 * 	Acpi processor hotplug support 				       	    *
 ****************************************************************************/

static int is_processor_present(acpi_handle handle);

L
Len Brown 已提交
810
static int is_processor_present(acpi_handle handle)
L
Linus Torvalds 已提交
811
{
L
Len Brown 已提交
812 813
	acpi_status status;
	unsigned long sta = 0;
L
Linus Torvalds 已提交
814 815 816


	status = acpi_evaluate_integer(handle, "_STA", NULL, &sta);
817
	if (ACPI_FAILURE(status) || !(sta & ACPI_STA_DEVICE_PRESENT)) {
818
		ACPI_EXCEPTION((AE_INFO, status, "Processor Device is not present"));
819
		return 0;
L
Linus Torvalds 已提交
820
	}
821
	return 1;
L
Linus Torvalds 已提交
822 823 824
}

static
L
Len Brown 已提交
825
int acpi_processor_device_add(acpi_handle handle, struct acpi_device **device)
L
Linus Torvalds 已提交
826
{
L
Len Brown 已提交
827 828 829
	acpi_handle phandle;
	struct acpi_device *pdev;
	struct acpi_processor *pr;
L
Linus Torvalds 已提交
830 831 832


	if (acpi_get_parent(handle, &phandle)) {
833
		return -ENODEV;
L
Linus Torvalds 已提交
834 835 836
	}

	if (acpi_bus_get_device(phandle, &pdev)) {
837
		return -ENODEV;
L
Linus Torvalds 已提交
838 839 840
	}

	if (acpi_bus_add(device, pdev, handle, ACPI_BUS_TYPE_PROCESSOR)) {
841
		return -ENODEV;
L
Linus Torvalds 已提交
842 843
	}

844
	acpi_bus_start(*device);
L
Linus Torvalds 已提交
845 846 847

	pr = acpi_driver_data(*device);
	if (!pr)
848
		return -ENODEV;
L
Linus Torvalds 已提交
849

L
Len Brown 已提交
850
	if ((pr->id >= 0) && (pr->id < NR_CPUS)) {
P
Patrick Mochel 已提交
851
		kobject_uevent(&(*device)->dev.kobj, KOBJ_ONLINE);
L
Linus Torvalds 已提交
852
	}
853
	return 0;
L
Linus Torvalds 已提交
854 855 856
}

static void
L
Len Brown 已提交
857
acpi_processor_hotplug_notify(acpi_handle handle, u32 event, void *data)
L
Linus Torvalds 已提交
858
{
L
Len Brown 已提交
859 860
	struct acpi_processor *pr;
	struct acpi_device *device = NULL;
L
Linus Torvalds 已提交
861 862 863 864 865 866 867
	int result;


	switch (event) {
	case ACPI_NOTIFY_BUS_CHECK:
	case ACPI_NOTIFY_DEVICE_CHECK:
		printk("Processor driver received %s event\n",
L
Len Brown 已提交
868 869
		       (event == ACPI_NOTIFY_BUS_CHECK) ?
		       "ACPI_NOTIFY_BUS_CHECK" : "ACPI_NOTIFY_DEVICE_CHECK");
L
Linus Torvalds 已提交
870 871 872 873 874 875 876

		if (!is_processor_present(handle))
			break;

		if (acpi_bus_get_device(handle, &device)) {
			result = acpi_processor_device_add(handle, &device);
			if (result)
877 878
				printk(KERN_ERR PREFIX
					    "Unable to add the device\n");
L
Linus Torvalds 已提交
879 880 881 882 883
			break;
		}

		pr = acpi_driver_data(device);
		if (!pr) {
884
			printk(KERN_ERR PREFIX "Driver data is NULL\n");
L
Linus Torvalds 已提交
885 886 887 888
			break;
		}

		if (pr->id >= 0 && (pr->id < NR_CPUS)) {
P
Patrick Mochel 已提交
889
			kobject_uevent(&device->dev.kobj, KOBJ_OFFLINE);
L
Linus Torvalds 已提交
890 891 892 893
			break;
		}

		result = acpi_processor_start(device);
L
Len Brown 已提交
894
		if ((!result) && ((pr->id >= 0) && (pr->id < NR_CPUS))) {
P
Patrick Mochel 已提交
895
			kobject_uevent(&device->dev.kobj, KOBJ_ONLINE);
L
Linus Torvalds 已提交
896
		} else {
897 898
			printk(KERN_ERR PREFIX "Device [%s] failed to start\n",
				    acpi_device_bid(device));
L
Linus Torvalds 已提交
899
		}
L
Len Brown 已提交
900
		break;
L
Linus Torvalds 已提交
901
	case ACPI_NOTIFY_EJECT_REQUEST:
L
Len Brown 已提交
902 903
		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
				  "received ACPI_NOTIFY_EJECT_REQUEST\n"));
L
Linus Torvalds 已提交
904 905

		if (acpi_bus_get_device(handle, &device)) {
906 907
			printk(KERN_ERR PREFIX
				    "Device don't exist, dropping EJECT\n");
L
Linus Torvalds 已提交
908 909 910 911
			break;
		}
		pr = acpi_driver_data(device);
		if (!pr) {
912 913
			printk(KERN_ERR PREFIX
				    "Driver data is NULL, dropping EJECT\n");
914
			return;
L
Linus Torvalds 已提交
915 916 917
		}

		if ((pr->id < NR_CPUS) && (cpu_present(pr->id)))
P
Patrick Mochel 已提交
918
			kobject_uevent(&device->dev.kobj, KOBJ_OFFLINE);
L
Linus Torvalds 已提交
919 920 921
		break;
	default:
		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
L
Len Brown 已提交
922
				  "Unsupported event [0x%x]\n", event));
L
Linus Torvalds 已提交
923 924 925
		break;
	}

926
	return;
L
Linus Torvalds 已提交
927 928 929 930
}

static acpi_status
processor_walk_namespace_cb(acpi_handle handle,
L
Len Brown 已提交
931
			    u32 lvl, void *context, void **rv)
L
Linus Torvalds 已提交
932
{
L
Len Brown 已提交
933
	acpi_status status;
L
Linus Torvalds 已提交
934
	int *action = context;
L
Len Brown 已提交
935
	acpi_object_type type = 0;
L
Linus Torvalds 已提交
936 937 938

	status = acpi_get_type(handle, &type);
	if (ACPI_FAILURE(status))
L
Len Brown 已提交
939
		return (AE_OK);
L
Linus Torvalds 已提交
940 941

	if (type != ACPI_TYPE_PROCESSOR)
L
Len Brown 已提交
942
		return (AE_OK);
L
Linus Torvalds 已提交
943

L
Len Brown 已提交
944
	switch (*action) {
L
Linus Torvalds 已提交
945 946
	case INSTALL_NOTIFY_HANDLER:
		acpi_install_notify_handler(handle,
L
Len Brown 已提交
947 948 949
					    ACPI_SYSTEM_NOTIFY,
					    acpi_processor_hotplug_notify,
					    NULL);
L
Linus Torvalds 已提交
950 951 952
		break;
	case UNINSTALL_NOTIFY_HANDLER:
		acpi_remove_notify_handler(handle,
L
Len Brown 已提交
953 954
					   ACPI_SYSTEM_NOTIFY,
					   acpi_processor_hotplug_notify);
L
Linus Torvalds 已提交
955 956 957 958 959
		break;
	default:
		break;
	}

L
Len Brown 已提交
960
	return (AE_OK);
L
Linus Torvalds 已提交
961 962
}

L
Len Brown 已提交
963
static acpi_status acpi_processor_hotadd_init(acpi_handle handle, int *p_cpu)
L
Linus Torvalds 已提交
964 965 966
{

	if (!is_processor_present(handle)) {
967
		return AE_ERROR;
L
Linus Torvalds 已提交
968 969 970
	}

	if (acpi_map_lsapic(handle, p_cpu))
971
		return AE_ERROR;
L
Linus Torvalds 已提交
972 973 974

	if (arch_register_cpu(*p_cpu)) {
		acpi_unmap_lsapic(*p_cpu);
975
		return AE_ERROR;
L
Linus Torvalds 已提交
976 977
	}

978
	return AE_OK;
L
Linus Torvalds 已提交
979 980
}

L
Len Brown 已提交
981
static int acpi_processor_handle_eject(struct acpi_processor *pr)
L
Linus Torvalds 已提交
982 983
{
	if (cpu_online(pr->id)) {
L
Len Brown 已提交
984
		return (-EINVAL);
L
Linus Torvalds 已提交
985 986 987
	}
	arch_unregister_cpu(pr->id);
	acpi_unmap_lsapic(pr->id);
L
Len Brown 已提交
988
	return (0);
L
Linus Torvalds 已提交
989 990
}
#else
L
Len Brown 已提交
991
static acpi_status acpi_processor_hotadd_init(acpi_handle handle, int *p_cpu)
L
Linus Torvalds 已提交
992 993 994
{
	return AE_ERROR;
}
L
Len Brown 已提交
995
static int acpi_processor_handle_eject(struct acpi_processor *pr)
L
Linus Torvalds 已提交
996
{
L
Len Brown 已提交
997
	return (-EINVAL);
L
Linus Torvalds 已提交
998 999 1000 1001 1002 1003 1004 1005 1006
}
#endif

static
void acpi_processor_install_hotplug_notify(void)
{
#ifdef CONFIG_ACPI_HOTPLUG_CPU
	int action = INSTALL_NOTIFY_HANDLER;
	acpi_walk_namespace(ACPI_TYPE_PROCESSOR,
L
Len Brown 已提交
1007 1008 1009
			    ACPI_ROOT_OBJECT,
			    ACPI_UINT32_MAX,
			    processor_walk_namespace_cb, &action, NULL);
L
Linus Torvalds 已提交
1010
#endif
1011
	register_hotcpu_notifier(&acpi_cpu_notifier);
L
Linus Torvalds 已提交
1012 1013 1014 1015 1016 1017 1018 1019
}

static
void acpi_processor_uninstall_hotplug_notify(void)
{
#ifdef CONFIG_ACPI_HOTPLUG_CPU
	int action = UNINSTALL_NOTIFY_HANDLER;
	acpi_walk_namespace(ACPI_TYPE_PROCESSOR,
L
Len Brown 已提交
1020 1021 1022
			    ACPI_ROOT_OBJECT,
			    ACPI_UINT32_MAX,
			    processor_walk_namespace_cb, &action, NULL);
L
Linus Torvalds 已提交
1023
#endif
1024
	unregister_hotcpu_notifier(&acpi_cpu_notifier);
L
Linus Torvalds 已提交
1025 1026 1027 1028 1029 1030 1031 1032
}

/*
 * We keep the driver loaded even when ACPI is not running.
 * This is needed for the powernow-k8 driver, that works even without
 * ACPI, but needs symbols from this driver
 */

L
Len Brown 已提交
1033
static int __init acpi_processor_init(void)
L
Linus Torvalds 已提交
1034
{
L
Len Brown 已提交
1035
	int result = 0;
L
Linus Torvalds 已提交
1036 1037 1038 1039 1040


	memset(&processors, 0, sizeof(processors));
	memset(&errata, 0, sizeof(errata));

1041 1042 1043
#ifdef CONFIG_SMP
	if (ACPI_FAILURE(acpi_get_table(ACPI_SIG_MADT, 0,
				(struct acpi_table_header **)&madt)))
R
Randy Dunlap 已提交
1044
		madt = NULL;
1045 1046
#endif

L
Linus Torvalds 已提交
1047 1048
	acpi_processor_dir = proc_mkdir(ACPI_PROCESSOR_CLASS, acpi_root_dir);
	if (!acpi_processor_dir)
1049
		return -ENOMEM;
L
Linus Torvalds 已提交
1050 1051 1052 1053 1054
	acpi_processor_dir->owner = THIS_MODULE;

	result = acpi_bus_register_driver(&acpi_processor_driver);
	if (result < 0) {
		remove_proc_entry(ACPI_PROCESSOR_CLASS, acpi_root_dir);
1055
		return result;
L
Linus Torvalds 已提交
1056 1057 1058 1059 1060 1061 1062 1063
	}

	acpi_processor_install_hotplug_notify();

	acpi_thermal_cpufreq_init();

	acpi_processor_ppc_init();

1064
	return 0;
L
Linus Torvalds 已提交
1065 1066
}

L
Len Brown 已提交
1067
static void __exit acpi_processor_exit(void)
L
Linus Torvalds 已提交
1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079
{

	acpi_processor_ppc_exit();

	acpi_thermal_cpufreq_exit();

	acpi_processor_uninstall_hotplug_notify();

	acpi_bus_unregister_driver(&acpi_processor_driver);

	remove_proc_entry(ACPI_PROCESSOR_CLASS, acpi_root_dir);

1080
	return;
L
Linus Torvalds 已提交
1081 1082 1083 1084 1085 1086 1087 1088
}

module_init(acpi_processor_init);
module_exit(acpi_processor_exit);

EXPORT_SYMBOL(acpi_processor_set_thermal_limit);

MODULE_ALIAS("processor");