processor_core.c 28.4 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

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 = {
114
	.owner = THIS_MODULE,
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
	}
	acpi_device_dir(device)->owner = THIS_MODULE;

	/* 'info' [R] */
329 330 331 332
	entry = proc_create_data(ACPI_PROCESSOR_FILE_INFO,
				 S_IRUGO, acpi_device_dir(device),
				 &acpi_processor_info_fops,
				 acpi_driver_data(device));
L
Linus Torvalds 已提交
333
	if (!entry)
334
		return -EIO;
L
Linus Torvalds 已提交
335 336

	/* 'throttling' [R/W] */
337 338 339 340 341
	entry = proc_create_data(ACPI_PROCESSOR_FILE_THROTTLING,
				 S_IFREG | S_IRUGO | S_IWUSR,
				 acpi_device_dir(device),
				 &acpi_processor_throttling_fops,
				 acpi_driver_data(device));
L
Linus Torvalds 已提交
342
	if (!entry)
343
		return -EIO;
L
Linus Torvalds 已提交
344 345

	/* 'limit' [R/W] */
346 347 348 349 350
	entry = proc_create_data(ACPI_PROCESSOR_FILE_LIMIT,
				 S_IFREG | S_IRUGO | S_IWUSR,
				 acpi_device_dir(device),
				 &acpi_processor_limit_fops,
				 acpi_driver_data(device));
L
Linus Torvalds 已提交
351
	if (!entry)
352 353
		return -EIO;
	return 0;
L
Linus Torvalds 已提交
354 355
}

L
Len Brown 已提交
356
static int acpi_processor_remove_fs(struct acpi_device *device)
L
Linus Torvalds 已提交
357 358 359
{

	if (acpi_device_dir(device)) {
L
Len Brown 已提交
360 361
		remove_proc_entry(ACPI_PROCESSOR_FILE_INFO,
				  acpi_device_dir(device));
L
Linus Torvalds 已提交
362
		remove_proc_entry(ACPI_PROCESSOR_FILE_THROTTLING,
L
Len Brown 已提交
363 364 365
				  acpi_device_dir(device));
		remove_proc_entry(ACPI_PROCESSOR_FILE_LIMIT,
				  acpi_device_dir(device));
L
Linus Torvalds 已提交
366 367 368 369
		remove_proc_entry(acpi_device_bid(device), acpi_processor_dir);
		acpi_device_dir(device) = NULL;
	}

370
	return 0;
L
Linus Torvalds 已提交
371 372 373
}

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

L
Linus Torvalds 已提交
375
#ifndef CONFIG_SMP
376
static int get_cpu_id(acpi_handle handle, u32 acpi_id) {return -1;}
L
Linus Torvalds 已提交
377 378
#else

379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402
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) {
403
			*apic_id = (lsapic->id << 8) | lsapic->eid;
404 405 406 407 408 409 410 411 412 413 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
			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;
}

476
static int get_cpu_id(acpi_handle handle, u32 acpi_id)
L
Linus Torvalds 已提交
477
{
478
	int i;
479
	int apic_id = -1;
L
Linus Torvalds 已提交
480

481 482 483 484 485
	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 已提交
486

487
	for_each_possible_cpu(i) {
M
Mike Travis 已提交
488
		if (cpu_physical_id(i) == apic_id)
489
			return i;
L
Linus Torvalds 已提交
490 491 492 493 494 495 496 497 498
	}
	return -1;
}
#endif

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

499
static int acpi_processor_get_info(struct acpi_processor *pr, unsigned has_uid)
L
Linus Torvalds 已提交
500
{
L
Len Brown 已提交
501 502 503
	acpi_status status = 0;
	union acpi_object object = { 0 };
	struct acpi_buffer buffer = { sizeof(union acpi_object), &object };
A
Ashok Raj 已提交
504
	int cpu_index;
L
Len Brown 已提交
505
	static int cpu0_initialized;
L
Linus Torvalds 已提交
506 507 508


	if (!pr)
509
		return -EINVAL;
L
Linus Torvalds 已提交
510 511 512 513 514 515 516 517 518 519

	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).
	 */
520
	if (acpi_gbl_FADT.pm2_control_block && acpi_gbl_FADT.pm2_control_length) {
L
Linus Torvalds 已提交
521 522
		pr->flags.bm_control = 1;
		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
L
Len Brown 已提交
523 524
				  "Bus mastering arbitration control present\n"));
	} else
L
Linus Torvalds 已提交
525
		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
L
Len Brown 已提交
526
				  "No bus mastering arbitration control\n"));
L
Linus Torvalds 已提交
527

528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548
	/* 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 已提交
549

550 551 552 553 554 555 556
		/*
		* 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 已提交
557

L
Len Brown 已提交
558
	/* Handle UP system running SMP kernel, with no LAPIC in MADT */
A
Ashok Raj 已提交
559
	if (!cpu0_initialized && (cpu_index == -1) &&
L
Len Brown 已提交
560 561 562 563 564 565 566 567 568 569 570 571 572
	    (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.
	 */
573
	if (pr->id == -1) {
L
Len Brown 已提交
574 575
		if (ACPI_FAILURE
		    (acpi_processor_hotadd_init(pr->handle, &pr->id))) {
576
			return -ENODEV;
L
Len Brown 已提交
577 578
		}
	}
L
Linus Torvalds 已提交
579 580

	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Processor [%d:%d]\n", pr->id,
L
Len Brown 已提交
581
			  pr->acpi_id));
L
Linus Torvalds 已提交
582 583 584 585

	if (!object.processor.pblk_address)
		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No PBLK (NULL address)\n"));
	else if (object.processor.pblk_length != 6)
586 587
		printk(KERN_ERR PREFIX "Invalid PBLK length [%d]\n",
			    object.processor.pblk_length);
L
Linus Torvalds 已提交
588 589
	else {
		pr->throttling.address = object.processor.pblk_address;
590 591
		pr->throttling.duty_offset = acpi_gbl_FADT.duty_offset;
		pr->throttling.duty_width = acpi_gbl_FADT.duty_width;
L
Linus Torvalds 已提交
592 593 594 595 596 597 598 599 600 601 602 603 604

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

605 606 607 608 609 610 611 612 613
	/*
	 * If ACPI describes a slot number for this CPU, we can use it
	 * ensure we get the right value in the "physical id" field
	 * of /proc/cpuinfo
	 */
	status = acpi_evaluate_object(pr->handle, "_SUN", NULL, &buffer);
	if (ACPI_SUCCESS(status))
		arch_fix_phys_package_id(pr->id, object.integer.value);

614
	return 0;
L
Linus Torvalds 已提交
615 616
}

617 618
static void *processor_device_array[NR_CPUS];

619
static int __cpuinit acpi_processor_start(struct acpi_device *device)
L
Linus Torvalds 已提交
620
{
L
Len Brown 已提交
621 622 623
	int result = 0;
	acpi_status status = AE_OK;
	struct acpi_processor *pr;
L
Linus Torvalds 已提交
624 625 626 627


	pr = acpi_driver_data(device);

628
	result = acpi_processor_get_info(pr, device->flags.unique_id);
L
Linus Torvalds 已提交
629 630
	if (result) {
		/* Processor is physically not present */
631
		return 0;
L
Linus Torvalds 已提交
632 633
	}

634
	BUG_ON((pr->id >= nr_cpu_ids) || (pr->id < 0));
L
Linus Torvalds 已提交
635

636 637 638 639 640 641
	/*
	 * 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 &&
642
	    processor_device_array[pr->id] != device) {
643
		printk(KERN_WARNING "BIOS reported wrong ACPI id "
L
Len Brown 已提交
644
			"for the processor\n");
645
		return -ENODEV;
646
	}
647
	processor_device_array[pr->id] = device;
648

L
Linus Torvalds 已提交
649 650 651 652 653 654 655
	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 已提交
656
					     acpi_processor_notify, pr);
L
Linus Torvalds 已提交
657

658 659 660
	/* _PDC call should be done before doing anything else (if reqd.). */
	arch_acpi_processor_init_pdc(pr);
	acpi_processor_set_pdc(pr);
661 662 663 664 665 666
#ifdef CONFIG_CPU_FREQ
	acpi_processor_ppc_has_changed(pr);
#endif
	acpi_processor_get_throttling_info(pr);
	acpi_processor_get_limit_info(pr);

667

L
Linus Torvalds 已提交
668 669
	acpi_processor_power_init(pr, device);

670 671
	pr->cdev = thermal_cooling_device_register("Processor", device,
						&processor_cooling_ops);
672 673 674 675
	if (IS_ERR(pr->cdev)) {
		result = PTR_ERR(pr->cdev);
		goto end;
	}
676 677 678 679 680 681 682 683 684 685 686 687 688 689 690

	printk(KERN_INFO PREFIX
		"%s is registered as cooling_device%d\n",
		device->dev.bus_id, pr->cdev->id);

	result = sysfs_create_link(&device->dev.kobj,
				   &pr->cdev->device.kobj,
				   "thermal_cooling");
	if (result)
		printk(KERN_ERR PREFIX "Create sysfs link\n");
	result = sysfs_create_link(&pr->cdev->device.kobj,
				   &device->dev.kobj,
				   "device");
	if (result)
		printk(KERN_ERR PREFIX "Create sysfs link\n");
691

L
Linus Torvalds 已提交
692 693
	if (pr->flags.throttling) {
		printk(KERN_INFO PREFIX "%s [%s] (supports",
L
Len Brown 已提交
694
		       acpi_device_name(device), acpi_device_bid(device));
L
Linus Torvalds 已提交
695 696 697 698
		printk(" %d throttling states", pr->throttling.state_count);
		printk(")\n");
	}

L
Len Brown 已提交
699
      end:
L
Linus Torvalds 已提交
700

701
	return result;
L
Linus Torvalds 已提交
702 703
}

L
Len Brown 已提交
704
static void acpi_processor_notify(acpi_handle handle, u32 event, void *data)
L
Linus Torvalds 已提交
705
{
706
	struct acpi_processor *pr = data;
L
Len Brown 已提交
707
	struct acpi_device *device = NULL;
708
	int saved;
L
Linus Torvalds 已提交
709 710

	if (!pr)
711
		return;
L
Linus Torvalds 已提交
712 713

	if (acpi_bus_get_device(pr->handle, &device))
714
		return;
L
Linus Torvalds 已提交
715 716 717

	switch (event) {
	case ACPI_PROCESSOR_NOTIFY_PERFORMANCE:
718
		saved = pr->performance_platform_limit;
L
Linus Torvalds 已提交
719
		acpi_processor_ppc_has_changed(pr);
720 721
		if (saved == pr->performance_platform_limit)
			break;
722
		acpi_bus_generate_proc_event(device, event,
L
Len Brown 已提交
723
					pr->performance_platform_limit);
724 725 726
		acpi_bus_generate_netlink_event(device->pnp.device_class,
						  device->dev.bus_id, event,
						  pr->performance_platform_limit);
L
Linus Torvalds 已提交
727 728 729
		break;
	case ACPI_PROCESSOR_NOTIFY_POWER:
		acpi_processor_cst_has_changed(pr);
730
		acpi_bus_generate_proc_event(device, event, 0);
731 732
		acpi_bus_generate_netlink_event(device->pnp.device_class,
						  device->dev.bus_id, event, 0);
L
Linus Torvalds 已提交
733
		break;
734 735
	case ACPI_PROCESSOR_NOTIFY_THROTTLING:
		acpi_processor_tstate_has_changed(pr);
736
		acpi_bus_generate_proc_event(device, event, 0);
737 738
		acpi_bus_generate_netlink_event(device->pnp.device_class,
						  device->dev.bus_id, event, 0);
L
Linus Torvalds 已提交
739 740
	default:
		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
L
Len Brown 已提交
741
				  "Unsupported event [0x%x]\n", event));
L
Linus Torvalds 已提交
742 743 744
		break;
	}

745
	return;
L
Linus Torvalds 已提交
746 747
}

748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766
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 已提交
767
static int acpi_processor_add(struct acpi_device *device)
L
Linus Torvalds 已提交
768
{
L
Len Brown 已提交
769
	struct acpi_processor *pr = NULL;
L
Linus Torvalds 已提交
770 771 772


	if (!device)
773
		return -EINVAL;
L
Linus Torvalds 已提交
774

775
	pr = kzalloc(sizeof(struct acpi_processor), GFP_KERNEL);
L
Linus Torvalds 已提交
776
	if (!pr)
777
		return -ENOMEM;
L
Linus Torvalds 已提交
778 779 780 781 782 783

	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;

784
	return 0;
L
Linus Torvalds 已提交
785 786
}

L
Len Brown 已提交
787
static int acpi_processor_remove(struct acpi_device *device, int type)
L
Linus Torvalds 已提交
788
{
L
Len Brown 已提交
789 790
	acpi_status status = AE_OK;
	struct acpi_processor *pr = NULL;
L
Linus Torvalds 已提交
791 792 793


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

796
	pr = acpi_driver_data(device);
L
Linus Torvalds 已提交
797

798
	if (pr->id >= nr_cpu_ids) {
L
Linus Torvalds 已提交
799
		kfree(pr);
800
		return 0;
L
Linus Torvalds 已提交
801 802 803 804
	}

	if (type == ACPI_BUS_REMOVAL_EJECT) {
		if (acpi_processor_handle_eject(pr))
805
			return -EINVAL;
L
Linus Torvalds 已提交
806 807 808 809 810
	}

	acpi_processor_power_exit(pr, device);

	status = acpi_remove_notify_handler(pr->handle, ACPI_DEVICE_NOTIFY,
L
Len Brown 已提交
811
					    acpi_processor_notify);
L
Linus Torvalds 已提交
812 813 814

	acpi_processor_remove_fs(device);

815 816 817 818 819 820
	if (pr->cdev) {
		sysfs_remove_link(&device->dev.kobj, "thermal_cooling");
		sysfs_remove_link(&pr->cdev->device.kobj, "device");
		thermal_cooling_device_unregister(pr->cdev);
		pr->cdev = NULL;
	}
821

L
Linus Torvalds 已提交
822
	processors[pr->id] = NULL;
823
	processor_device_array[pr->id] = NULL;
L
Linus Torvalds 已提交
824 825
	kfree(pr);

826
	return 0;
L
Linus Torvalds 已提交
827 828 829 830 831 832 833
}

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

L
Len Brown 已提交
834
static int is_processor_present(acpi_handle handle)
L
Linus Torvalds 已提交
835
{
L
Len Brown 已提交
836 837
	acpi_status status;
	unsigned long sta = 0;
L
Linus Torvalds 已提交
838 839 840


	status = acpi_evaluate_integer(handle, "_STA", NULL, &sta);
841 842 843 844

	if (ACPI_SUCCESS(status) && (sta & ACPI_STA_DEVICE_PRESENT))
		return 1;

845 846 847 848 849 850 851 852 853
	/*
	 * _STA is mandatory for a processor that supports hot plug
	 */
	if (status == AE_NOT_FOUND)
		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
				"Processor does not support hot plug\n"));
	else
		ACPI_EXCEPTION((AE_INFO, status,
				"Processor Device is not present"));
854
	return 0;
L
Linus Torvalds 已提交
855 856 857
}

static
L
Len Brown 已提交
858
int acpi_processor_device_add(acpi_handle handle, struct acpi_device **device)
L
Linus Torvalds 已提交
859
{
L
Len Brown 已提交
860 861 862
	acpi_handle phandle;
	struct acpi_device *pdev;
	struct acpi_processor *pr;
L
Linus Torvalds 已提交
863 864 865


	if (acpi_get_parent(handle, &phandle)) {
866
		return -ENODEV;
L
Linus Torvalds 已提交
867 868 869
	}

	if (acpi_bus_get_device(phandle, &pdev)) {
870
		return -ENODEV;
L
Linus Torvalds 已提交
871 872 873
	}

	if (acpi_bus_add(device, pdev, handle, ACPI_BUS_TYPE_PROCESSOR)) {
874
		return -ENODEV;
L
Linus Torvalds 已提交
875 876
	}

877
	acpi_bus_start(*device);
L
Linus Torvalds 已提交
878 879 880

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

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

889 890
static void __ref acpi_processor_hotplug_notify(acpi_handle handle,
						u32 event, void *data)
L
Linus Torvalds 已提交
891
{
L
Len Brown 已提交
892 893
	struct acpi_processor *pr;
	struct acpi_device *device = NULL;
L
Linus Torvalds 已提交
894 895 896 897 898 899
	int result;


	switch (event) {
	case ACPI_NOTIFY_BUS_CHECK:
	case ACPI_NOTIFY_DEVICE_CHECK:
900 901
		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
		"Processor driver received %s event\n",
L
Len Brown 已提交
902
		       (event == ACPI_NOTIFY_BUS_CHECK) ?
903
		       "ACPI_NOTIFY_BUS_CHECK" : "ACPI_NOTIFY_DEVICE_CHECK"));
L
Linus Torvalds 已提交
904 905 906 907 908 909 910

		if (!is_processor_present(handle))
			break;

		if (acpi_bus_get_device(handle, &device)) {
			result = acpi_processor_device_add(handle, &device);
			if (result)
911 912
				printk(KERN_ERR PREFIX
					    "Unable to add the device\n");
L
Linus Torvalds 已提交
913 914 915 916 917
			break;
		}

		pr = acpi_driver_data(device);
		if (!pr) {
918
			printk(KERN_ERR PREFIX "Driver data is NULL\n");
L
Linus Torvalds 已提交
919 920 921
			break;
		}

922
		if (pr->id >= 0 && (pr->id < nr_cpu_ids)) {
P
Patrick Mochel 已提交
923
			kobject_uevent(&device->dev.kobj, KOBJ_OFFLINE);
L
Linus Torvalds 已提交
924 925 926 927
			break;
		}

		result = acpi_processor_start(device);
928
		if ((!result) && ((pr->id >= 0) && (pr->id < nr_cpu_ids))) {
P
Patrick Mochel 已提交
929
			kobject_uevent(&device->dev.kobj, KOBJ_ONLINE);
L
Linus Torvalds 已提交
930
		} else {
931 932
			printk(KERN_ERR PREFIX "Device [%s] failed to start\n",
				    acpi_device_bid(device));
L
Linus Torvalds 已提交
933
		}
L
Len Brown 已提交
934
		break;
L
Linus Torvalds 已提交
935
	case ACPI_NOTIFY_EJECT_REQUEST:
L
Len Brown 已提交
936 937
		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
				  "received ACPI_NOTIFY_EJECT_REQUEST\n"));
L
Linus Torvalds 已提交
938 939

		if (acpi_bus_get_device(handle, &device)) {
940 941
			printk(KERN_ERR PREFIX
				    "Device don't exist, dropping EJECT\n");
L
Linus Torvalds 已提交
942 943 944 945
			break;
		}
		pr = acpi_driver_data(device);
		if (!pr) {
946 947
			printk(KERN_ERR PREFIX
				    "Driver data is NULL, dropping EJECT\n");
948
			return;
L
Linus Torvalds 已提交
949 950
		}

951
		if ((pr->id < nr_cpu_ids) && (cpu_present(pr->id)))
P
Patrick Mochel 已提交
952
			kobject_uevent(&device->dev.kobj, KOBJ_OFFLINE);
L
Linus Torvalds 已提交
953 954 955
		break;
	default:
		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
L
Len Brown 已提交
956
				  "Unsupported event [0x%x]\n", event));
L
Linus Torvalds 已提交
957 958 959
		break;
	}

960
	return;
L
Linus Torvalds 已提交
961 962 963 964
}

static acpi_status
processor_walk_namespace_cb(acpi_handle handle,
L
Len Brown 已提交
965
			    u32 lvl, void *context, void **rv)
L
Linus Torvalds 已提交
966
{
L
Len Brown 已提交
967
	acpi_status status;
L
Linus Torvalds 已提交
968
	int *action = context;
L
Len Brown 已提交
969
	acpi_object_type type = 0;
L
Linus Torvalds 已提交
970 971 972

	status = acpi_get_type(handle, &type);
	if (ACPI_FAILURE(status))
L
Len Brown 已提交
973
		return (AE_OK);
L
Linus Torvalds 已提交
974 975

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

L
Len Brown 已提交
978
	switch (*action) {
L
Linus Torvalds 已提交
979 980
	case INSTALL_NOTIFY_HANDLER:
		acpi_install_notify_handler(handle,
L
Len Brown 已提交
981 982 983
					    ACPI_SYSTEM_NOTIFY,
					    acpi_processor_hotplug_notify,
					    NULL);
L
Linus Torvalds 已提交
984 985 986
		break;
	case UNINSTALL_NOTIFY_HANDLER:
		acpi_remove_notify_handler(handle,
L
Len Brown 已提交
987 988
					   ACPI_SYSTEM_NOTIFY,
					   acpi_processor_hotplug_notify);
L
Linus Torvalds 已提交
989 990 991 992 993
		break;
	default:
		break;
	}

L
Len Brown 已提交
994
	return (AE_OK);
L
Linus Torvalds 已提交
995 996
}

L
Len Brown 已提交
997
static acpi_status acpi_processor_hotadd_init(acpi_handle handle, int *p_cpu)
L
Linus Torvalds 已提交
998 999 1000
{

	if (!is_processor_present(handle)) {
1001
		return AE_ERROR;
L
Linus Torvalds 已提交
1002 1003 1004
	}

	if (acpi_map_lsapic(handle, p_cpu))
1005
		return AE_ERROR;
L
Linus Torvalds 已提交
1006 1007 1008

	if (arch_register_cpu(*p_cpu)) {
		acpi_unmap_lsapic(*p_cpu);
1009
		return AE_ERROR;
L
Linus Torvalds 已提交
1010 1011
	}

1012
	return AE_OK;
L
Linus Torvalds 已提交
1013 1014
}

L
Len Brown 已提交
1015
static int acpi_processor_handle_eject(struct acpi_processor *pr)
L
Linus Torvalds 已提交
1016
{
1017 1018 1019
	if (cpu_online(pr->id))
		cpu_down(pr->id);

L
Linus Torvalds 已提交
1020 1021
	arch_unregister_cpu(pr->id);
	acpi_unmap_lsapic(pr->id);
L
Len Brown 已提交
1022
	return (0);
L
Linus Torvalds 已提交
1023 1024
}
#else
L
Len Brown 已提交
1025
static acpi_status acpi_processor_hotadd_init(acpi_handle handle, int *p_cpu)
L
Linus Torvalds 已提交
1026 1027 1028
{
	return AE_ERROR;
}
L
Len Brown 已提交
1029
static int acpi_processor_handle_eject(struct acpi_processor *pr)
L
Linus Torvalds 已提交
1030
{
L
Len Brown 已提交
1031
	return (-EINVAL);
L
Linus Torvalds 已提交
1032 1033 1034 1035 1036 1037 1038 1039 1040
}
#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 已提交
1041 1042 1043
			    ACPI_ROOT_OBJECT,
			    ACPI_UINT32_MAX,
			    processor_walk_namespace_cb, &action, NULL);
L
Linus Torvalds 已提交
1044
#endif
1045
	register_hotcpu_notifier(&acpi_cpu_notifier);
L
Linus Torvalds 已提交
1046 1047 1048 1049 1050 1051 1052 1053
}

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 已提交
1054 1055 1056
			    ACPI_ROOT_OBJECT,
			    ACPI_UINT32_MAX,
			    processor_walk_namespace_cb, &action, NULL);
L
Linus Torvalds 已提交
1057
#endif
1058
	unregister_hotcpu_notifier(&acpi_cpu_notifier);
L
Linus Torvalds 已提交
1059 1060 1061 1062 1063 1064 1065 1066
}

/*
 * 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 已提交
1067
static int __init acpi_processor_init(void)
L
Linus Torvalds 已提交
1068
{
L
Len Brown 已提交
1069
	int result = 0;
L
Linus Torvalds 已提交
1070 1071 1072 1073 1074


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

1075 1076 1077
#ifdef CONFIG_SMP
	if (ACPI_FAILURE(acpi_get_table(ACPI_SIG_MADT, 0,
				(struct acpi_table_header **)&madt)))
R
Randy Dunlap 已提交
1078
		madt = NULL;
1079 1080
#endif

L
Linus Torvalds 已提交
1081 1082
	acpi_processor_dir = proc_mkdir(ACPI_PROCESSOR_CLASS, acpi_root_dir);
	if (!acpi_processor_dir)
1083
		return -ENOMEM;
L
Linus Torvalds 已提交
1084 1085
	acpi_processor_dir->owner = THIS_MODULE;

1086 1087 1088 1089
	result = cpuidle_register_driver(&acpi_idle_driver);
	if (result < 0)
		goto out_proc;

L
Linus Torvalds 已提交
1090
	result = acpi_bus_register_driver(&acpi_processor_driver);
1091 1092
	if (result < 0)
		goto out_cpuidle;
L
Linus Torvalds 已提交
1093 1094 1095 1096 1097 1098 1099

	acpi_processor_install_hotplug_notify();

	acpi_thermal_cpufreq_init();

	acpi_processor_ppc_init();

1100 1101
	acpi_processor_throttling_init();

1102
	return 0;
1103 1104 1105 1106 1107 1108 1109 1110

out_cpuidle:
	cpuidle_unregister_driver(&acpi_idle_driver);

out_proc:
	remove_proc_entry(ACPI_PROCESSOR_CLASS, acpi_root_dir);

	return result;
L
Linus Torvalds 已提交
1111 1112
}

L
Len Brown 已提交
1113
static void __exit acpi_processor_exit(void)
L
Linus Torvalds 已提交
1114 1115 1116 1117 1118 1119 1120 1121 1122
{
	acpi_processor_ppc_exit();

	acpi_thermal_cpufreq_exit();

	acpi_processor_uninstall_hotplug_notify();

	acpi_bus_unregister_driver(&acpi_processor_driver);

1123 1124
	cpuidle_unregister_driver(&acpi_idle_driver);

L
Linus Torvalds 已提交
1125 1126
	remove_proc_entry(ACPI_PROCESSOR_CLASS, acpi_root_dir);

1127
	return;
L
Linus Torvalds 已提交
1128 1129 1130 1131 1132 1133 1134 1135
}

module_init(acpi_processor_init);
module_exit(acpi_processor_exit);

EXPORT_SYMBOL(acpi_processor_set_thermal_limit);

MODULE_ALIAS("processor");