processor_driver.c 25.0 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>
48
#include <linux/slab.h>
L
Linus Torvalds 已提交
49 50 51 52 53 54 55 56 57 58 59 60 61 62

#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>

63 64
#define PREFIX "ACPI: "

L
Linus Torvalds 已提交
65 66 67 68 69 70 71
#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
72
#define ACPI_PROCESSOR_NOTIFY_THROTTLING	0x82
L
Linus Torvalds 已提交
73 74 75 76 77

#define ACPI_PROCESSOR_LIMIT_USER	0
#define ACPI_PROCESSOR_LIMIT_THERMAL	1

#define _COMPONENT		ACPI_PROCESSOR_COMPONENT
78
ACPI_MODULE_NAME("processor_driver");
L
Linus Torvalds 已提交
79

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

L
Len Brown 已提交
84 85
static int acpi_processor_add(struct acpi_device *device);
static int acpi_processor_remove(struct acpi_device *device, int type);
86
#ifdef CONFIG_ACPI_PROCFS
L
Linus Torvalds 已提交
87
static int acpi_processor_info_open_fs(struct inode *inode, struct file *file);
88
#endif
89
static void acpi_processor_notify(struct acpi_device *device, u32 event);
L
Linus Torvalds 已提交
90 91
static acpi_status acpi_processor_hotadd_init(acpi_handle handle, int *p_cpu);
static int acpi_processor_handle_eject(struct acpi_processor *pr);
92

L
Linus Torvalds 已提交
93

94
static const struct acpi_device_id processor_device_ids[] = {
95
	{ACPI_PROCESSOR_OBJECT_HID, 0},
96
	{"ACPI0007", 0},
97 98 99 100
	{"", 0},
};
MODULE_DEVICE_TABLE(acpi, processor_device_ids);

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

#define INSTALL_NOTIFY_HANDLER		1
#define UNINSTALL_NOTIFY_HANDLER	2
116
#ifdef CONFIG_ACPI_PROCFS
117
static const struct file_operations acpi_processor_info_fops = {
118
	.owner = THIS_MODULE,
L
Len Brown 已提交
119 120 121 122
	.open = acpi_processor_info_open_fs,
	.read = seq_read,
	.llseek = seq_lseek,
	.release = single_release,
L
Linus Torvalds 已提交
123
};
124
#endif
L
Linus Torvalds 已提交
125

126
DEFINE_PER_CPU(struct acpi_processor *, processors);
127 128
EXPORT_PER_CPU_SYMBOL(processors);

129
struct acpi_processor_errata errata __read_mostly;
L
Linus Torvalds 已提交
130 131 132 133 134

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

L
Len Brown 已提交
135
static int acpi_processor_errata_piix4(struct pci_dev *dev)
L
Linus Torvalds 已提交
136
{
L
Len Brown 已提交
137 138
	u8 value1 = 0;
	u8 value2 = 0;
L
Linus Torvalds 已提交
139 140 141


	if (!dev)
142
		return -EINVAL;
L
Linus Torvalds 已提交
143 144 145 146 147

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

148
	switch (dev->revision) {
L
Linus Torvalds 已提交
149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165
	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;
	}

166
	switch (dev->revision) {
L
Linus Torvalds 已提交
167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195

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

233
	return 0;
L
Linus Torvalds 已提交
234 235
}

236
static int acpi_processor_errata(struct acpi_processor *pr)
L
Linus Torvalds 已提交
237
{
L
Len Brown 已提交
238 239
	int result = 0;
	struct pci_dev *dev = NULL;
L
Linus Torvalds 已提交
240 241 242


	if (!pr)
243
		return -EINVAL;
L
Linus Torvalds 已提交
244 245 246 247 248

	/*
	 * PIIX4
	 */
	dev = pci_get_subsys(PCI_VENDOR_ID_INTEL,
L
Len Brown 已提交
249 250
			     PCI_DEVICE_ID_INTEL_82371AB_3, PCI_ANY_ID,
			     PCI_ANY_ID, NULL);
L
Linus Torvalds 已提交
251 252 253 254 255
	if (dev) {
		result = acpi_processor_errata_piix4(dev);
		pci_dev_put(dev);
	}

256
	return result;
L
Linus Torvalds 已提交
257 258 259 260 261 262
}

/* --------------------------------------------------------------------------
                              FS Interface (/proc)
   -------------------------------------------------------------------------- */

263
#ifdef CONFIG_ACPI_PROCFS
L
Len Brown 已提交
264
static struct proc_dir_entry *acpi_processor_dir = NULL;
L
Linus Torvalds 已提交
265 266 267

static int acpi_processor_info_seq_show(struct seq_file *seq, void *offset)
{
268
	struct acpi_processor *pr = seq->private;
L
Linus Torvalds 已提交
269 270 271 272 273 274


	if (!pr)
		goto end;

	seq_printf(seq, "processor id:            %d\n"
L
Len Brown 已提交
275 276 277 278 279 280 281 282 283 284 285 286 287
		   "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:
288
	return 0;
L
Linus Torvalds 已提交
289 290 291 292 293
}

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 已提交
294
			   PDE(inode)->data);
L
Linus Torvalds 已提交
295 296
}

297
static int __cpuinit acpi_processor_add_fs(struct acpi_device *device)
L
Linus Torvalds 已提交
298
{
L
Len Brown 已提交
299
	struct proc_dir_entry *entry = NULL;
L
Linus Torvalds 已提交
300 301 302 303


	if (!acpi_device_dir(device)) {
		acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device),
L
Len Brown 已提交
304
						     acpi_processor_dir);
L
Linus Torvalds 已提交
305
		if (!acpi_device_dir(device))
306
			return -ENODEV;
L
Linus Torvalds 已提交
307 308 309
	}

	/* 'info' [R] */
310 311 312 313
	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 已提交
314
	if (!entry)
315
		return -EIO;
L
Linus Torvalds 已提交
316 317

	/* 'throttling' [R/W] */
318 319 320 321 322
	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 已提交
323
	if (!entry)
324
		return -EIO;
L
Linus Torvalds 已提交
325 326

	/* 'limit' [R/W] */
327 328 329 330 331
	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 已提交
332
	if (!entry)
333 334
		return -EIO;
	return 0;
L
Linus Torvalds 已提交
335
}
L
Len Brown 已提交
336
static int acpi_processor_remove_fs(struct acpi_device *device)
L
Linus Torvalds 已提交
337 338 339
{

	if (acpi_device_dir(device)) {
L
Len Brown 已提交
340 341
		remove_proc_entry(ACPI_PROCESSOR_FILE_INFO,
				  acpi_device_dir(device));
L
Linus Torvalds 已提交
342
		remove_proc_entry(ACPI_PROCESSOR_FILE_THROTTLING,
L
Len Brown 已提交
343 344 345
				  acpi_device_dir(device));
		remove_proc_entry(ACPI_PROCESSOR_FILE_LIMIT,
				  acpi_device_dir(device));
L
Linus Torvalds 已提交
346 347 348 349
		remove_proc_entry(acpi_device_bid(device), acpi_processor_dir);
		acpi_device_dir(device) = NULL;
	}

350
	return 0;
L
Linus Torvalds 已提交
351
}
352 353 354 355 356 357 358 359 360 361
#else
static inline int acpi_processor_add_fs(struct acpi_device *device)
{
	return 0;
}
static inline int acpi_processor_remove_fs(struct acpi_device *device)
{
	return 0;
}
#endif
L
Linus Torvalds 已提交
362 363 364 365 366

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

367
static int acpi_processor_get_info(struct acpi_device *device)
L
Linus Torvalds 已提交
368
{
L
Len Brown 已提交
369 370 371
	acpi_status status = 0;
	union acpi_object object = { 0 };
	struct acpi_buffer buffer = { sizeof(union acpi_object), &object };
372 373
	struct acpi_processor *pr;
	int cpu_index, device_declaration = 0;
L
Len Brown 已提交
374
	static int cpu0_initialized;
L
Linus Torvalds 已提交
375

376
	pr = acpi_driver_data(device);
L
Linus Torvalds 已提交
377
	if (!pr)
378
		return -EINVAL;
L
Linus Torvalds 已提交
379 380 381 382 383 384 385 386 387 388

	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).
	 */
389
	if (acpi_gbl_FADT.pm2_control_block && acpi_gbl_FADT.pm2_control_length) {
L
Linus Torvalds 已提交
390 391
		pr->flags.bm_control = 1;
		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
L
Len Brown 已提交
392 393
				  "Bus mastering arbitration control present\n"));
	} else
L
Linus Torvalds 已提交
394
		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
L
Len Brown 已提交
395
				  "No bus mastering arbitration control\n"));
L
Linus Torvalds 已提交
396

397 398 399 400 401 402 403 404 405 406 407 408 409 410 411
	if (!strcmp(acpi_device_hid(device), ACPI_PROCESSOR_OBJECT_HID)) {
		/* Declared with "Processor" statement; match ProcessorID */
		status = acpi_evaluate_object(pr->handle, NULL, NULL, &buffer);
		if (ACPI_FAILURE(status)) {
			printk(KERN_ERR PREFIX "Evaluating processor object\n");
			return -ENODEV;
		}

		/*
		 * 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;
	} else {
412 413 414 415
		/*
		 * Declared with "Device" statement; match _UID.
		 * Note that we don't handle string _UIDs yet.
		 */
416
		unsigned long long value;
417 418 419
		status = acpi_evaluate_integer(pr->handle, METHOD_NAME__UID,
						NULL, &value);
		if (ACPI_FAILURE(status)) {
420 421
			printk(KERN_ERR PREFIX
			    "Evaluating processor _UID [%#x]\n", status);
422 423
			return -ENODEV;
		}
424
		device_declaration = 1;
425 426
		pr->acpi_id = value;
	}
427
	cpu_index = acpi_get_cpuid(pr->handle, device_declaration, pr->acpi_id);
L
Linus Torvalds 已提交
428

L
Len Brown 已提交
429
	/* Handle UP system running SMP kernel, with no LAPIC in MADT */
A
Ashok Raj 已提交
430
	if (!cpu0_initialized && (cpu_index == -1) &&
L
Len Brown 已提交
431 432 433 434 435 436 437 438 439 440 441 442 443
	    (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.
	 */
444
	if (pr->id == -1) {
L
Len Brown 已提交
445 446
		if (ACPI_FAILURE
		    (acpi_processor_hotadd_init(pr->handle, &pr->id))) {
447
			return -ENODEV;
L
Len Brown 已提交
448 449
		}
	}
450 451 452 453 454 455 456 457 458 459
	/*
	 * On some boxes several processors use the same processor bus id.
	 * But they are located in different scope. For example:
	 * \_SB.SCK0.CPU0
	 * \_SB.SCK1.CPU0
	 * Rename the processor device bus id. And the new bus id will be
	 * generated as the following format:
	 * CPU+CPU ID.
	 */
	sprintf(acpi_device_bid(device), "CPU%X", pr->id);
L
Linus Torvalds 已提交
460
	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Processor [%d:%d]\n", pr->id,
L
Len Brown 已提交
461
			  pr->acpi_id));
L
Linus Torvalds 已提交
462 463 464 465

	if (!object.processor.pblk_address)
		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No PBLK (NULL address)\n"));
	else if (object.processor.pblk_length != 6)
466 467
		printk(KERN_ERR PREFIX "Invalid PBLK length [%d]\n",
			    object.processor.pblk_length);
L
Linus Torvalds 已提交
468 469
	else {
		pr->throttling.address = object.processor.pblk_address;
470 471
		pr->throttling.duty_offset = acpi_gbl_FADT.duty_offset;
		pr->throttling.duty_width = acpi_gbl_FADT.duty_width;
L
Linus Torvalds 已提交
472 473 474 475 476 477 478 479 480 481 482 483 484

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

485 486 487 488 489 490 491 492 493
	/*
	 * 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);

494
	return 0;
L
Linus Torvalds 已提交
495 496
}

497
static DEFINE_PER_CPU(void *, processor_device_array);
498

499
static void acpi_processor_notify(struct acpi_device *device, u32 event)
L
Linus Torvalds 已提交
500
{
501
	struct acpi_processor *pr = acpi_driver_data(device);
502
	int saved;
L
Linus Torvalds 已提交
503 504

	if (!pr)
505
		return;
L
Linus Torvalds 已提交
506 507 508

	switch (event) {
	case ACPI_PROCESSOR_NOTIFY_PERFORMANCE:
509
		saved = pr->performance_platform_limit;
510
		acpi_processor_ppc_has_changed(pr, 1);
511 512
		if (saved == pr->performance_platform_limit)
			break;
513
		acpi_bus_generate_proc_event(device, event,
L
Len Brown 已提交
514
					pr->performance_platform_limit);
515
		acpi_bus_generate_netlink_event(device->pnp.device_class,
516
						  dev_name(&device->dev), event,
517
						  pr->performance_platform_limit);
L
Linus Torvalds 已提交
518 519 520
		break;
	case ACPI_PROCESSOR_NOTIFY_POWER:
		acpi_processor_cst_has_changed(pr);
521
		acpi_bus_generate_proc_event(device, event, 0);
522
		acpi_bus_generate_netlink_event(device->pnp.device_class,
523
						  dev_name(&device->dev), event, 0);
L
Linus Torvalds 已提交
524
		break;
525 526
	case ACPI_PROCESSOR_NOTIFY_THROTTLING:
		acpi_processor_tstate_has_changed(pr);
527
		acpi_bus_generate_proc_event(device, event, 0);
528
		acpi_bus_generate_netlink_event(device->pnp.device_class,
529
						  dev_name(&device->dev), event, 0);
L
Linus Torvalds 已提交
530 531
	default:
		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
L
Len Brown 已提交
532
				  "Unsupported event [0x%x]\n", event));
L
Linus Torvalds 已提交
533 534 535
		break;
	}

536
	return;
L
Linus Torvalds 已提交
537 538
}

539 540 541 542
static int acpi_cpu_soft_notify(struct notifier_block *nfb,
		unsigned long action, void *hcpu)
{
	unsigned int cpu = (unsigned long)hcpu;
543
	struct acpi_processor *pr = per_cpu(processors, cpu);
544 545

	if (action == CPU_ONLINE && pr) {
546
		acpi_processor_ppc_has_changed(pr, 0);
547 548 549 550 551 552 553 554 555 556 557
		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,
};

558
static int __cpuinit acpi_processor_add(struct acpi_device *device)
L
Linus Torvalds 已提交
559
{
L
Len Brown 已提交
560
	struct acpi_processor *pr = NULL;
561 562
	int result = 0;
	struct sys_device *sysdev;
L
Linus Torvalds 已提交
563

564
	pr = kzalloc(sizeof(struct acpi_processor), GFP_KERNEL);
L
Linus Torvalds 已提交
565
	if (!pr)
566
		return -ENOMEM;
L
Linus Torvalds 已提交
567

568
	if (!zalloc_cpumask_var(&pr->throttling.shared_cpu_map, GFP_KERNEL)) {
569 570 571 572
		kfree(pr);
		return -ENOMEM;
	}

L
Linus Torvalds 已提交
573 574 575
	pr->handle = device->handle;
	strcpy(acpi_device_name(device), ACPI_PROCESSOR_DEVICE_NAME);
	strcpy(acpi_device_class(device), ACPI_PROCESSOR_CLASS);
576
	device->driver_data = pr;
L
Linus Torvalds 已提交
577

578
	result = acpi_processor_get_info(device);
L
Linus Torvalds 已提交
579 580
	if (result) {
		/* Processor is physically not present */
581
		return 0;
L
Linus Torvalds 已提交
582 583
	}

584 585 586 587 588
#ifdef CONFIG_SMP
	if (pr->id >= setup_max_cpus && pr->id != 0)
		return 0;
#endif

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

591 592 593 594 595
	/*
	 * Buggy BIOS check
	 * ACPI id of processors can be reported wrongly by the BIOS.
	 * Don't trust it blindly
	 */
596 597
	if (per_cpu(processor_device_array, pr->id) != NULL &&
	    per_cpu(processor_device_array, pr->id) != device) {
598
		printk(KERN_WARNING "BIOS reported wrong ACPI id "
L
Len Brown 已提交
599
			"for the processor\n");
600 601
		result = -ENODEV;
		goto err_free_cpumask;
602
	}
603
	per_cpu(processor_device_array, pr->id) = device;
604

605
	per_cpu(processors, pr->id) = pr;
L
Linus Torvalds 已提交
606 607 608

	result = acpi_processor_add_fs(device);
	if (result)
609
		goto err_free_cpumask;
L
Linus Torvalds 已提交
610

611
	sysdev = get_cpu_sysdev(pr->id);
612 613 614 615
	if (sysfs_create_link(&device->dev.kobj, &sysdev->kobj, "sysdev")) {
		result = -EFAULT;
		goto err_remove_fs;
	}
616

617
#ifdef CONFIG_CPU_FREQ
618
	acpi_processor_ppc_has_changed(pr, 0);
619 620 621 622
#endif
	acpi_processor_get_throttling_info(pr);
	acpi_processor_get_limit_info(pr);

623

624 625
	if (cpuidle_get_driver() == &acpi_idle_driver)
		acpi_processor_power_init(pr, device);
L
Linus Torvalds 已提交
626

627 628
	pr->cdev = thermal_cooling_device_register("Processor", device,
						&processor_cooling_ops);
629 630
	if (IS_ERR(pr->cdev)) {
		result = PTR_ERR(pr->cdev);
631
		goto err_power_exit;
632
	}
633

634
	dev_dbg(&device->dev, "registered as cooling_device%d\n",
635
		 pr->cdev->id);
636 637 638 639

	result = sysfs_create_link(&device->dev.kobj,
				   &pr->cdev->device.kobj,
				   "thermal_cooling");
640
	if (result) {
641
		printk(KERN_ERR PREFIX "Create sysfs link\n");
642 643
		goto err_thermal_unregister;
	}
644 645 646
	result = sysfs_create_link(&pr->cdev->device.kobj,
				   &device->dev.kobj,
				   "device");
647
	if (result) {
648
		printk(KERN_ERR PREFIX "Create sysfs link\n");
649 650
		goto err_remove_sysfs;
	}
651

652
	return 0;
653 654 655 656 657 658 659 660 661

err_remove_sysfs:
	sysfs_remove_link(&device->dev.kobj, "thermal_cooling");
err_thermal_unregister:
	thermal_cooling_device_unregister(pr->cdev);
err_power_exit:
	acpi_processor_power_exit(pr, device);
err_remove_fs:
	acpi_processor_remove_fs(device);
662 663
err_free_cpumask:
	free_cpumask_var(pr->throttling.shared_cpu_map);
L
Linus Torvalds 已提交
664

665
	return result;
L
Linus Torvalds 已提交
666 667
}

L
Len Brown 已提交
668
static int acpi_processor_remove(struct acpi_device *device, int type)
L
Linus Torvalds 已提交
669
{
L
Len Brown 已提交
670
	struct acpi_processor *pr = NULL;
L
Linus Torvalds 已提交
671 672 673


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

676
	pr = acpi_driver_data(device);
L
Linus Torvalds 已提交
677

678 679
	if (pr->id >= nr_cpu_ids)
		goto free;
L
Linus Torvalds 已提交
680 681 682

	if (type == ACPI_BUS_REMOVAL_EJECT) {
		if (acpi_processor_handle_eject(pr))
683
			return -EINVAL;
L
Linus Torvalds 已提交
684 685 686 687
	}

	acpi_processor_power_exit(pr, device);

688 689
	sysfs_remove_link(&device->dev.kobj, "sysdev");

L
Linus Torvalds 已提交
690 691
	acpi_processor_remove_fs(device);

692 693 694 695 696 697
	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;
	}
698

699 700
	per_cpu(processors, pr->id) = NULL;
	per_cpu(processor_device_array, pr->id) = NULL;
701 702 703

free:
	free_cpumask_var(pr->throttling.shared_cpu_map);
L
Linus Torvalds 已提交
704 705
	kfree(pr);

706
	return 0;
L
Linus Torvalds 已提交
707 708 709 710 711 712 713
}

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

L
Len Brown 已提交
714
static int is_processor_present(acpi_handle handle)
L
Linus Torvalds 已提交
715
{
L
Len Brown 已提交
716
	acpi_status status;
717
	unsigned long long sta = 0;
L
Linus Torvalds 已提交
718 719 720


	status = acpi_evaluate_integer(handle, "_STA", NULL, &sta);
721 722 723 724

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

725 726 727 728 729 730 731 732 733
	/*
	 * _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"));
734
	return 0;
L
Linus Torvalds 已提交
735 736 737
}

static
L
Len Brown 已提交
738
int acpi_processor_device_add(acpi_handle handle, struct acpi_device **device)
L
Linus Torvalds 已提交
739
{
L
Len Brown 已提交
740 741
	acpi_handle phandle;
	struct acpi_device *pdev;
L
Linus Torvalds 已提交
742 743 744


	if (acpi_get_parent(handle, &phandle)) {
745
		return -ENODEV;
L
Linus Torvalds 已提交
746 747 748
	}

	if (acpi_bus_get_device(phandle, &pdev)) {
749
		return -ENODEV;
L
Linus Torvalds 已提交
750 751 752
	}

	if (acpi_bus_add(device, pdev, handle, ACPI_BUS_TYPE_PROCESSOR)) {
753
		return -ENODEV;
L
Linus Torvalds 已提交
754 755
	}

756
	return 0;
L
Linus Torvalds 已提交
757 758
}

759 760
static void __ref acpi_processor_hotplug_notify(acpi_handle handle,
						u32 event, void *data)
L
Linus Torvalds 已提交
761
{
L
Len Brown 已提交
762 763
	struct acpi_processor *pr;
	struct acpi_device *device = NULL;
L
Linus Torvalds 已提交
764 765 766 767 768 769
	int result;


	switch (event) {
	case ACPI_NOTIFY_BUS_CHECK:
	case ACPI_NOTIFY_DEVICE_CHECK:
770 771
		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
		"Processor driver received %s event\n",
L
Len Brown 已提交
772
		       (event == ACPI_NOTIFY_BUS_CHECK) ?
773
		       "ACPI_NOTIFY_BUS_CHECK" : "ACPI_NOTIFY_DEVICE_CHECK"));
L
Linus Torvalds 已提交
774 775 776 777 778 779 780

		if (!is_processor_present(handle))
			break;

		if (acpi_bus_get_device(handle, &device)) {
			result = acpi_processor_device_add(handle, &device);
			if (result)
781 782
				printk(KERN_ERR PREFIX
					    "Unable to add the device\n");
L
Linus Torvalds 已提交
783 784
			break;
		}
L
Len Brown 已提交
785
		break;
L
Linus Torvalds 已提交
786
	case ACPI_NOTIFY_EJECT_REQUEST:
L
Len Brown 已提交
787 788
		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
				  "received ACPI_NOTIFY_EJECT_REQUEST\n"));
L
Linus Torvalds 已提交
789 790

		if (acpi_bus_get_device(handle, &device)) {
791 792
			printk(KERN_ERR PREFIX
				    "Device don't exist, dropping EJECT\n");
L
Linus Torvalds 已提交
793 794 795 796
			break;
		}
		pr = acpi_driver_data(device);
		if (!pr) {
797 798
			printk(KERN_ERR PREFIX
				    "Driver data is NULL, dropping EJECT\n");
799
			return;
L
Linus Torvalds 已提交
800 801 802 803
		}
		break;
	default:
		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
L
Len Brown 已提交
804
				  "Unsupported event [0x%x]\n", event));
L
Linus Torvalds 已提交
805 806 807
		break;
	}

808
	return;
L
Linus Torvalds 已提交
809 810 811 812
}

static acpi_status
processor_walk_namespace_cb(acpi_handle handle,
L
Len Brown 已提交
813
			    u32 lvl, void *context, void **rv)
L
Linus Torvalds 已提交
814
{
L
Len Brown 已提交
815
	acpi_status status;
L
Linus Torvalds 已提交
816
	int *action = context;
L
Len Brown 已提交
817
	acpi_object_type type = 0;
L
Linus Torvalds 已提交
818 819 820

	status = acpi_get_type(handle, &type);
	if (ACPI_FAILURE(status))
L
Len Brown 已提交
821
		return (AE_OK);
L
Linus Torvalds 已提交
822 823

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

L
Len Brown 已提交
826
	switch (*action) {
L
Linus Torvalds 已提交
827 828
	case INSTALL_NOTIFY_HANDLER:
		acpi_install_notify_handler(handle,
L
Len Brown 已提交
829 830 831
					    ACPI_SYSTEM_NOTIFY,
					    acpi_processor_hotplug_notify,
					    NULL);
L
Linus Torvalds 已提交
832 833 834
		break;
	case UNINSTALL_NOTIFY_HANDLER:
		acpi_remove_notify_handler(handle,
L
Len Brown 已提交
835 836
					   ACPI_SYSTEM_NOTIFY,
					   acpi_processor_hotplug_notify);
L
Linus Torvalds 已提交
837 838 839 840 841
		break;
	default:
		break;
	}

L
Len Brown 已提交
842
	return (AE_OK);
L
Linus Torvalds 已提交
843 844
}

L
Len Brown 已提交
845
static acpi_status acpi_processor_hotadd_init(acpi_handle handle, int *p_cpu)
L
Linus Torvalds 已提交
846 847 848
{

	if (!is_processor_present(handle)) {
849
		return AE_ERROR;
L
Linus Torvalds 已提交
850 851 852
	}

	if (acpi_map_lsapic(handle, p_cpu))
853
		return AE_ERROR;
L
Linus Torvalds 已提交
854 855 856

	if (arch_register_cpu(*p_cpu)) {
		acpi_unmap_lsapic(*p_cpu);
857
		return AE_ERROR;
L
Linus Torvalds 已提交
858 859
	}

860
	return AE_OK;
L
Linus Torvalds 已提交
861 862
}

L
Len Brown 已提交
863
static int acpi_processor_handle_eject(struct acpi_processor *pr)
L
Linus Torvalds 已提交
864
{
865 866 867
	if (cpu_online(pr->id))
		cpu_down(pr->id);

L
Linus Torvalds 已提交
868 869
	arch_unregister_cpu(pr->id);
	acpi_unmap_lsapic(pr->id);
L
Len Brown 已提交
870
	return (0);
L
Linus Torvalds 已提交
871 872
}
#else
L
Len Brown 已提交
873
static acpi_status acpi_processor_hotadd_init(acpi_handle handle, int *p_cpu)
L
Linus Torvalds 已提交
874 875 876
{
	return AE_ERROR;
}
L
Len Brown 已提交
877
static int acpi_processor_handle_eject(struct acpi_processor *pr)
L
Linus Torvalds 已提交
878
{
L
Len Brown 已提交
879
	return (-EINVAL);
L
Linus Torvalds 已提交
880 881 882 883 884 885 886 887 888
}
#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 已提交
889 890
			    ACPI_ROOT_OBJECT,
			    ACPI_UINT32_MAX,
891
			    processor_walk_namespace_cb, NULL, &action, NULL);
L
Linus Torvalds 已提交
892
#endif
893
	register_hotcpu_notifier(&acpi_cpu_notifier);
L
Linus Torvalds 已提交
894 895 896 897 898 899 900 901
}

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 已提交
902 903
			    ACPI_ROOT_OBJECT,
			    ACPI_UINT32_MAX,
904
			    processor_walk_namespace_cb, NULL, &action, NULL);
L
Linus Torvalds 已提交
905
#endif
906
	unregister_hotcpu_notifier(&acpi_cpu_notifier);
L
Linus Torvalds 已提交
907 908 909 910 911 912 913 914
}

/*
 * 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 已提交
915
static int __init acpi_processor_init(void)
L
Linus Torvalds 已提交
916
{
L
Len Brown 已提交
917
	int result = 0;
L
Linus Torvalds 已提交
918

919 920 921
	if (acpi_disabled)
		return 0;

L
Linus Torvalds 已提交
922 923
	memset(&errata, 0, sizeof(errata));

924
#ifdef CONFIG_ACPI_PROCFS
L
Linus Torvalds 已提交
925 926
	acpi_processor_dir = proc_mkdir(ACPI_PROCESSOR_CLASS, acpi_root_dir);
	if (!acpi_processor_dir)
927
		return -ENOMEM;
928
#endif
929

930
	if (!cpuidle_register_driver(&acpi_idle_driver)) {
931 932
		printk(KERN_DEBUG "ACPI: %s registered with cpuidle\n",
			acpi_idle_driver.name);
933 934 935 936
	} else {
		printk(KERN_DEBUG "ACPI: acpi_idle yielding to %s",
			cpuidle_get_driver()->name);
	}
937

L
Linus Torvalds 已提交
938
	result = acpi_bus_register_driver(&acpi_processor_driver);
939 940
	if (result < 0)
		goto out_cpuidle;
L
Linus Torvalds 已提交
941 942 943 944 945 946 947

	acpi_processor_install_hotplug_notify();

	acpi_thermal_cpufreq_init();

	acpi_processor_ppc_init();

948 949
	acpi_processor_throttling_init();

950
	return 0;
951 952 953 954

out_cpuidle:
	cpuidle_unregister_driver(&acpi_idle_driver);

955
#ifdef CONFIG_ACPI_PROCFS
956
	remove_proc_entry(ACPI_PROCESSOR_CLASS, acpi_root_dir);
957
#endif
958 959

	return result;
L
Linus Torvalds 已提交
960 961
}

L
Len Brown 已提交
962
static void __exit acpi_processor_exit(void)
L
Linus Torvalds 已提交
963
{
964 965 966
	if (acpi_disabled)
		return;

L
Linus Torvalds 已提交
967 968 969 970 971 972 973 974
	acpi_processor_ppc_exit();

	acpi_thermal_cpufreq_exit();

	acpi_processor_uninstall_hotplug_notify();

	acpi_bus_unregister_driver(&acpi_processor_driver);

975 976
	cpuidle_unregister_driver(&acpi_idle_driver);

977
#ifdef CONFIG_ACPI_PROCFS
L
Linus Torvalds 已提交
978
	remove_proc_entry(ACPI_PROCESSOR_CLASS, acpi_root_dir);
979
#endif
L
Linus Torvalds 已提交
980

981
	return;
L
Linus Torvalds 已提交
982 983 984 985 986 987 988 989
}

module_init(acpi_processor_init);
module_exit(acpi_processor_exit);

EXPORT_SYMBOL(acpi_processor_set_thermal_limit);

MODULE_ALIAS("processor");