processor_core.c 27.2 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
/*
 * 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>
47
#include <linux/cpuidle.h>
L
Linus Torvalds 已提交
48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69

#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
70
#define ACPI_PROCESSOR_NOTIFY_THROTTLING	0x82
L
Linus Torvalds 已提交
71 72 73 74 75

#define ACPI_PROCESSOR_LIMIT_USER	0
#define ACPI_PROCESSOR_LIMIT_THERMAL	1

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

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

L
Len Brown 已提交
82 83 84
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 已提交
85
static int acpi_processor_info_open_fs(struct inode *inode, struct file *file);
L
Len Brown 已提交
86
static void acpi_processor_notify(acpi_handle handle, u32 event, void *data);
L
Linus Torvalds 已提交
87 88
static acpi_status acpi_processor_hotadd_init(acpi_handle handle, int *p_cpu);
static int acpi_processor_handle_eject(struct acpi_processor *pr);
89 90
extern int acpi_processor_tstate_has_changed(struct acpi_processor *pr);

L
Linus Torvalds 已提交
91

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

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

#define INSTALL_NOTIFY_HANDLER		1
#define UNINSTALL_NOTIFY_HANDLER	2

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

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

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

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


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

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

141
	switch (dev->revision) {
L
Linus Torvalds 已提交
142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158
	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;
	}

159
	switch (dev->revision) {
L
Linus Torvalds 已提交
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 188

	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 已提交
189 190
				     PCI_DEVICE_ID_INTEL_82371AB,
				     PCI_ANY_ID, PCI_ANY_ID, NULL);
L
Linus Torvalds 已提交
191 192 193 194 195 196 197 198 199 200 201 202 203 204 205
		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 已提交
206 207
				     PCI_DEVICE_ID_INTEL_82371AB_0,
				     PCI_ANY_ID, PCI_ANY_ID, NULL);
L
Linus Torvalds 已提交
208 209 210 211 212 213 214 215 216 217 218 219 220
		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 已提交
221
				  "Bus master activity detection (BM-IDE) erratum enabled\n"));
L
Linus Torvalds 已提交
222 223
	if (errata.piix4.fdma)
		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
L
Len Brown 已提交
224
				  "Type-F DMA livelock erratum (C3 disabled)\n"));
L
Linus Torvalds 已提交
225

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

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


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

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

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

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

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


266
	if (!pdc_in)
267
		return status;
268

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

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

275
	return status;
276 277
}

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

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

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


	if (!pr)
		goto end;

	seq_printf(seq, "processor id:            %d\n"
L
Len Brown 已提交
293 294 295 296 297 298 299 300 301 302 303 304 305
		   "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:
306
	return 0;
L
Linus Torvalds 已提交
307 308 309 310 311
}

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 已提交
312
			   PDE(inode)->data);
L
Linus Torvalds 已提交
313 314
}

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


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

	/* 'info' [R] */
	entry = create_proc_entry(ACPI_PROCESSOR_FILE_INFO,
L
Len Brown 已提交
330
				  S_IRUGO, acpi_device_dir(device));
L
Linus Torvalds 已提交
331
	if (!entry)
332
		return -EIO;
L
Linus Torvalds 已提交
333 334 335 336 337 338 339 340
	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 已提交
341 342
				  S_IFREG | S_IRUGO | S_IWUSR,
				  acpi_device_dir(device));
L
Linus Torvalds 已提交
343
	if (!entry)
344
		return -EIO;
L
Linus Torvalds 已提交
345 346 347 348 349 350 351 352
	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 已提交
353 354
				  S_IFREG | S_IRUGO | S_IWUSR,
				  acpi_device_dir(device));
L
Linus Torvalds 已提交
355
	if (!entry)
356
		return -EIO;
L
Linus Torvalds 已提交
357 358 359 360 361 362
	else {
		entry->proc_fops = &acpi_processor_limit_fops;
		entry->data = acpi_driver_data(device);
		entry->owner = THIS_MODULE;
	}

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

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

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

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

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

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

389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412
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) {
413
			*apic_id = (lsapic->id << 8) | lsapic->eid;
414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 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
			return 1;
		/* Check against optional uid */
		} else if (entry->length >= 16 &&
			lsapic->uid == acpi_id) {
			*apic_id = lsapic->uid;
			return 1;
		}
	}
	return 0;
}

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;
}

486
static int get_cpu_id(acpi_handle handle, u32 acpi_id)
L
Linus Torvalds 已提交
487
{
488
	int i;
489
	int apic_id = -1;
L
Linus Torvalds 已提交
490

491 492 493 494 495
	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 已提交
496

497
	for (i = 0; i < NR_CPUS; ++i) {
M
Mike Travis 已提交
498
		if (cpu_physical_id(i) == apic_id)
499
			return i;
L
Linus Torvalds 已提交
500 501 502 503 504 505 506 507 508
	}
	return -1;
}
#endif

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

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


	if (!pr)
519
		return -EINVAL;
L
Linus Torvalds 已提交
520 521 522 523 524 525 526 527 528 529

	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).
	 */
530
	if (acpi_gbl_FADT.pm2_control_block && acpi_gbl_FADT.pm2_control_length) {
L
Linus Torvalds 已提交
531 532
		pr->flags.bm_control = 1;
		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
L
Len Brown 已提交
533 534
				  "Bus mastering arbitration control present\n"));
	} else
L
Linus Torvalds 已提交
535
		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
L
Len Brown 已提交
536
				  "No bus mastering arbitration control\n"));
L
Linus Torvalds 已提交
537

538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558
	/* 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 已提交
559

560 561 562 563 564 565 566
		/*
		* 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 已提交
567

L
Len Brown 已提交
568
	/* Handle UP system running SMP kernel, with no LAPIC in MADT */
A
Ashok Raj 已提交
569
	if (!cpu0_initialized && (cpu_index == -1) &&
L
Len Brown 已提交
570 571 572 573 574 575 576 577 578 579 580 581 582
	    (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.
	 */
583
	if (pr->id == -1) {
L
Len Brown 已提交
584 585
		if (ACPI_FAILURE
		    (acpi_processor_hotadd_init(pr->handle, &pr->id))) {
586
			return -ENODEV;
L
Len Brown 已提交
587 588
		}
	}
L
Linus Torvalds 已提交
589 590

	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Processor [%d:%d]\n", pr->id,
L
Len Brown 已提交
591
			  pr->acpi_id));
L
Linus Torvalds 已提交
592 593 594 595

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

		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);

621
	return 0;
L
Linus Torvalds 已提交
622 623
}

624 625
static void *processor_device_array[NR_CPUS];

626
static int __cpuinit acpi_processor_start(struct acpi_device *device)
L
Linus Torvalds 已提交
627
{
L
Len Brown 已提交
628 629 630
	int result = 0;
	acpi_status status = AE_OK;
	struct acpi_processor *pr;
L
Linus Torvalds 已提交
631 632 633 634


	pr = acpi_driver_data(device);

635
	result = acpi_processor_get_info(pr, device->flags.unique_id);
L
Linus Torvalds 已提交
636 637
	if (result) {
		/* Processor is physically not present */
638
		return 0;
L
Linus Torvalds 已提交
639 640 641 642
	}

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

643 644 645 646 647 648
	/*
	 * 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 &&
649
	    processor_device_array[pr->id] != device) {
L
Len Brown 已提交
650 651
		printk(KERN_WARNING "BIOS reported wrong ACPI id"
			"for the processor\n");
652
		return -ENODEV;
653
	}
654
	processor_device_array[pr->id] = device;
655

L
Linus Torvalds 已提交
656 657 658 659 660 661 662
	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 已提交
663
					     acpi_processor_notify, pr);
L
Linus Torvalds 已提交
664

665 666 667 668
	/* _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 已提交
669 670 671 672
	acpi_processor_power_init(pr, device);

	if (pr->flags.throttling) {
		printk(KERN_INFO PREFIX "%s [%s] (supports",
L
Len Brown 已提交
673
		       acpi_device_name(device), acpi_device_bid(device));
L
Linus Torvalds 已提交
674 675 676 677
		printk(" %d throttling states", pr->throttling.state_count);
		printk(")\n");
	}

L
Len Brown 已提交
678
      end:
L
Linus Torvalds 已提交
679

680
	return result;
L
Linus Torvalds 已提交
681 682
}

L
Len Brown 已提交
683
static void acpi_processor_notify(acpi_handle handle, u32 event, void *data)
L
Linus Torvalds 已提交
684
{
685
	struct acpi_processor *pr = data;
L
Len Brown 已提交
686
	struct acpi_device *device = NULL;
L
Linus Torvalds 已提交
687 688 689


	if (!pr)
690
		return;
L
Linus Torvalds 已提交
691 692

	if (acpi_bus_get_device(pr->handle, &device))
693
		return;
L
Linus Torvalds 已提交
694 695 696 697

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

721
	return;
L
Linus Torvalds 已提交
722 723
}

724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742
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 已提交
743
static int acpi_processor_add(struct acpi_device *device)
L
Linus Torvalds 已提交
744
{
L
Len Brown 已提交
745
	struct acpi_processor *pr = NULL;
L
Linus Torvalds 已提交
746 747 748


	if (!device)
749
		return -EINVAL;
L
Linus Torvalds 已提交
750

751
	pr = kzalloc(sizeof(struct acpi_processor), GFP_KERNEL);
L
Linus Torvalds 已提交
752
	if (!pr)
753
		return -ENOMEM;
L
Linus Torvalds 已提交
754 755 756 757 758 759

	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;

760
	return 0;
L
Linus Torvalds 已提交
761 762
}

L
Len Brown 已提交
763
static int acpi_processor_remove(struct acpi_device *device, int type)
L
Linus Torvalds 已提交
764
{
L
Len Brown 已提交
765 766
	acpi_status status = AE_OK;
	struct acpi_processor *pr = NULL;
L
Linus Torvalds 已提交
767 768 769


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

772
	pr = acpi_driver_data(device);
L
Linus Torvalds 已提交
773 774 775

	if (pr->id >= NR_CPUS) {
		kfree(pr);
776
		return 0;
L
Linus Torvalds 已提交
777 778 779 780
	}

	if (type == ACPI_BUS_REMOVAL_EJECT) {
		if (acpi_processor_handle_eject(pr))
781
			return -EINVAL;
L
Linus Torvalds 已提交
782 783 784 785 786
	}

	acpi_processor_power_exit(pr, device);

	status = acpi_remove_notify_handler(pr->handle, ACPI_DEVICE_NOTIFY,
L
Len Brown 已提交
787
					    acpi_processor_notify);
L
Linus Torvalds 已提交
788 789 790 791 792 793 794

	acpi_processor_remove_fs(device);

	processors[pr->id] = NULL;

	kfree(pr);

795
	return 0;
L
Linus Torvalds 已提交
796 797 798 799 800 801 802 803 804
}

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

static int is_processor_present(acpi_handle handle);

L
Len Brown 已提交
805
static int is_processor_present(acpi_handle handle)
L
Linus Torvalds 已提交
806
{
L
Len Brown 已提交
807 808
	acpi_status status;
	unsigned long sta = 0;
L
Linus Torvalds 已提交
809 810 811


	status = acpi_evaluate_integer(handle, "_STA", NULL, &sta);
812
	if (ACPI_FAILURE(status) || !(sta & ACPI_STA_DEVICE_PRESENT)) {
813
		ACPI_EXCEPTION((AE_INFO, status, "Processor Device is not present"));
814
		return 0;
L
Linus Torvalds 已提交
815
	}
816
	return 1;
L
Linus Torvalds 已提交
817 818 819
}

static
L
Len Brown 已提交
820
int acpi_processor_device_add(acpi_handle handle, struct acpi_device **device)
L
Linus Torvalds 已提交
821
{
L
Len Brown 已提交
822 823 824
	acpi_handle phandle;
	struct acpi_device *pdev;
	struct acpi_processor *pr;
L
Linus Torvalds 已提交
825 826 827


	if (acpi_get_parent(handle, &phandle)) {
828
		return -ENODEV;
L
Linus Torvalds 已提交
829 830 831
	}

	if (acpi_bus_get_device(phandle, &pdev)) {
832
		return -ENODEV;
L
Linus Torvalds 已提交
833 834 835
	}

	if (acpi_bus_add(device, pdev, handle, ACPI_BUS_TYPE_PROCESSOR)) {
836
		return -ENODEV;
L
Linus Torvalds 已提交
837 838
	}

839
	acpi_bus_start(*device);
L
Linus Torvalds 已提交
840 841 842

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

L
Len Brown 已提交
845
	if ((pr->id >= 0) && (pr->id < NR_CPUS)) {
P
Patrick Mochel 已提交
846
		kobject_uevent(&(*device)->dev.kobj, KOBJ_ONLINE);
L
Linus Torvalds 已提交
847
	}
848
	return 0;
L
Linus Torvalds 已提交
849 850 851
}

static void
L
Len Brown 已提交
852
acpi_processor_hotplug_notify(acpi_handle handle, u32 event, void *data)
L
Linus Torvalds 已提交
853
{
L
Len Brown 已提交
854 855
	struct acpi_processor *pr;
	struct acpi_device *device = NULL;
L
Linus Torvalds 已提交
856 857 858 859 860 861 862
	int result;


	switch (event) {
	case ACPI_NOTIFY_BUS_CHECK:
	case ACPI_NOTIFY_DEVICE_CHECK:
		printk("Processor driver received %s event\n",
L
Len Brown 已提交
863 864
		       (event == ACPI_NOTIFY_BUS_CHECK) ?
		       "ACPI_NOTIFY_BUS_CHECK" : "ACPI_NOTIFY_DEVICE_CHECK");
L
Linus Torvalds 已提交
865 866 867 868 869 870 871

		if (!is_processor_present(handle))
			break;

		if (acpi_bus_get_device(handle, &device)) {
			result = acpi_processor_device_add(handle, &device);
			if (result)
872 873
				printk(KERN_ERR PREFIX
					    "Unable to add the device\n");
L
Linus Torvalds 已提交
874 875 876 877 878
			break;
		}

		pr = acpi_driver_data(device);
		if (!pr) {
879
			printk(KERN_ERR PREFIX "Driver data is NULL\n");
L
Linus Torvalds 已提交
880 881 882 883
			break;
		}

		if (pr->id >= 0 && (pr->id < NR_CPUS)) {
P
Patrick Mochel 已提交
884
			kobject_uevent(&device->dev.kobj, KOBJ_OFFLINE);
L
Linus Torvalds 已提交
885 886 887 888
			break;
		}

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

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

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

921
	return;
L
Linus Torvalds 已提交
922 923 924 925
}

static acpi_status
processor_walk_namespace_cb(acpi_handle handle,
L
Len Brown 已提交
926
			    u32 lvl, void *context, void **rv)
L
Linus Torvalds 已提交
927
{
L
Len Brown 已提交
928
	acpi_status status;
L
Linus Torvalds 已提交
929
	int *action = context;
L
Len Brown 已提交
930
	acpi_object_type type = 0;
L
Linus Torvalds 已提交
931 932 933

	status = acpi_get_type(handle, &type);
	if (ACPI_FAILURE(status))
L
Len Brown 已提交
934
		return (AE_OK);
L
Linus Torvalds 已提交
935 936

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

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

L
Len Brown 已提交
955
	return (AE_OK);
L
Linus Torvalds 已提交
956 957
}

L
Len Brown 已提交
958
static acpi_status acpi_processor_hotadd_init(acpi_handle handle, int *p_cpu)
L
Linus Torvalds 已提交
959 960 961
{

	if (!is_processor_present(handle)) {
962
		return AE_ERROR;
L
Linus Torvalds 已提交
963 964 965
	}

	if (acpi_map_lsapic(handle, p_cpu))
966
		return AE_ERROR;
L
Linus Torvalds 已提交
967 968 969

	if (arch_register_cpu(*p_cpu)) {
		acpi_unmap_lsapic(*p_cpu);
970
		return AE_ERROR;
L
Linus Torvalds 已提交
971 972
	}

973
	return AE_OK;
L
Linus Torvalds 已提交
974 975
}

L
Len Brown 已提交
976
static int acpi_processor_handle_eject(struct acpi_processor *pr)
L
Linus Torvalds 已提交
977 978
{
	if (cpu_online(pr->id)) {
L
Len Brown 已提交
979
		return (-EINVAL);
L
Linus Torvalds 已提交
980 981 982
	}
	arch_unregister_cpu(pr->id);
	acpi_unmap_lsapic(pr->id);
L
Len Brown 已提交
983
	return (0);
L
Linus Torvalds 已提交
984 985
}
#else
L
Len Brown 已提交
986
static acpi_status acpi_processor_hotadd_init(acpi_handle handle, int *p_cpu)
L
Linus Torvalds 已提交
987 988 989
{
	return AE_ERROR;
}
L
Len Brown 已提交
990
static int acpi_processor_handle_eject(struct acpi_processor *pr)
L
Linus Torvalds 已提交
991
{
L
Len Brown 已提交
992
	return (-EINVAL);
L
Linus Torvalds 已提交
993 994 995 996 997 998 999 1000 1001
}
#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 已提交
1002 1003 1004
			    ACPI_ROOT_OBJECT,
			    ACPI_UINT32_MAX,
			    processor_walk_namespace_cb, &action, NULL);
L
Linus Torvalds 已提交
1005
#endif
1006
	register_hotcpu_notifier(&acpi_cpu_notifier);
L
Linus Torvalds 已提交
1007 1008 1009 1010 1011 1012 1013 1014
}

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 已提交
1015 1016 1017
			    ACPI_ROOT_OBJECT,
			    ACPI_UINT32_MAX,
			    processor_walk_namespace_cb, &action, NULL);
L
Linus Torvalds 已提交
1018
#endif
1019
	unregister_hotcpu_notifier(&acpi_cpu_notifier);
L
Linus Torvalds 已提交
1020 1021 1022 1023 1024 1025 1026 1027
}

/*
 * 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 已提交
1028
static int __init acpi_processor_init(void)
L
Linus Torvalds 已提交
1029
{
L
Len Brown 已提交
1030
	int result = 0;
L
Linus Torvalds 已提交
1031 1032 1033 1034 1035


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

1036 1037 1038
#ifdef CONFIG_SMP
	if (ACPI_FAILURE(acpi_get_table(ACPI_SIG_MADT, 0,
				(struct acpi_table_header **)&madt)))
R
Randy Dunlap 已提交
1039
		madt = NULL;
1040 1041
#endif

L
Linus Torvalds 已提交
1042 1043
	acpi_processor_dir = proc_mkdir(ACPI_PROCESSOR_CLASS, acpi_root_dir);
	if (!acpi_processor_dir)
1044
		return -ENOMEM;
L
Linus Torvalds 已提交
1045 1046
	acpi_processor_dir->owner = THIS_MODULE;

1047 1048 1049 1050
	result = cpuidle_register_driver(&acpi_idle_driver);
	if (result < 0)
		goto out_proc;

L
Linus Torvalds 已提交
1051
	result = acpi_bus_register_driver(&acpi_processor_driver);
1052 1053
	if (result < 0)
		goto out_cpuidle;
L
Linus Torvalds 已提交
1054 1055 1056 1057 1058 1059 1060

	acpi_processor_install_hotplug_notify();

	acpi_thermal_cpufreq_init();

	acpi_processor_ppc_init();

1061
	return 0;
1062 1063 1064 1065 1066 1067 1068 1069

out_cpuidle:
	cpuidle_unregister_driver(&acpi_idle_driver);

out_proc:
	remove_proc_entry(ACPI_PROCESSOR_CLASS, acpi_root_dir);

	return result;
L
Linus Torvalds 已提交
1070 1071
}

L
Len Brown 已提交
1072
static void __exit acpi_processor_exit(void)
L
Linus Torvalds 已提交
1073 1074 1075 1076 1077 1078 1079 1080 1081
{
	acpi_processor_ppc_exit();

	acpi_thermal_cpufreq_exit();

	acpi_processor_uninstall_hotplug_notify();

	acpi_bus_unregister_driver(&acpi_processor_driver);

1082 1083
	cpuidle_unregister_driver(&acpi_idle_driver);

L
Linus Torvalds 已提交
1084 1085
	remove_proc_entry(ACPI_PROCESSOR_CLASS, acpi_root_dir);

1086
	return;
L
Linus Torvalds 已提交
1087 1088 1089 1090 1091 1092 1093 1094
}

module_init(acpi_processor_init);
module_exit(acpi_processor_exit);

EXPORT_SYMBOL(acpi_processor_set_thermal_limit);

MODULE_ALIAS("processor");