processor_driver.c 24.7 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
	BUG_ON((pr->id >= nr_cpu_ids) || (pr->id < 0));
L
Linus Torvalds 已提交
585

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

600
	per_cpu(processors, pr->id) = pr;
L
Linus Torvalds 已提交
601 602 603

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

606
	sysdev = get_cpu_sysdev(pr->id);
607 608 609 610
	if (sysfs_create_link(&device->dev.kobj, &sysdev->kobj, "sysdev")) {
		result = -EFAULT;
		goto err_remove_fs;
	}
611

612
#ifdef CONFIG_CPU_FREQ
613
	acpi_processor_ppc_has_changed(pr, 0);
614 615 616 617
#endif
	acpi_processor_get_throttling_info(pr);
	acpi_processor_get_limit_info(pr);

618

L
Linus Torvalds 已提交
619 620
	acpi_processor_power_init(pr, device);

621 622
	pr->cdev = thermal_cooling_device_register("Processor", device,
						&processor_cooling_ops);
623 624
	if (IS_ERR(pr->cdev)) {
		result = PTR_ERR(pr->cdev);
625
		goto err_power_exit;
626
	}
627

628
	dev_dbg(&device->dev, "registered as cooling_device%d\n",
629
		 pr->cdev->id);
630 631 632 633

	result = sysfs_create_link(&device->dev.kobj,
				   &pr->cdev->device.kobj,
				   "thermal_cooling");
634
	if (result) {
635
		printk(KERN_ERR PREFIX "Create sysfs link\n");
636 637
		goto err_thermal_unregister;
	}
638 639 640
	result = sysfs_create_link(&pr->cdev->device.kobj,
				   &device->dev.kobj,
				   "device");
641
	if (result) {
642
		printk(KERN_ERR PREFIX "Create sysfs link\n");
643 644
		goto err_remove_sysfs;
	}
645

646
	return 0;
647 648 649 650 651 652 653 654 655

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);
656 657
err_free_cpumask:
	free_cpumask_var(pr->throttling.shared_cpu_map);
L
Linus Torvalds 已提交
658

659
	return result;
L
Linus Torvalds 已提交
660 661
}

L
Len Brown 已提交
662
static int acpi_processor_remove(struct acpi_device *device, int type)
L
Linus Torvalds 已提交
663
{
L
Len Brown 已提交
664
	struct acpi_processor *pr = NULL;
L
Linus Torvalds 已提交
665 666 667


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

670
	pr = acpi_driver_data(device);
L
Linus Torvalds 已提交
671

672 673
	if (pr->id >= nr_cpu_ids)
		goto free;
L
Linus Torvalds 已提交
674 675 676

	if (type == ACPI_BUS_REMOVAL_EJECT) {
		if (acpi_processor_handle_eject(pr))
677
			return -EINVAL;
L
Linus Torvalds 已提交
678 679 680 681
	}

	acpi_processor_power_exit(pr, device);

682 683
	sysfs_remove_link(&device->dev.kobj, "sysdev");

L
Linus Torvalds 已提交
684 685
	acpi_processor_remove_fs(device);

686 687 688 689 690 691
	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;
	}
692

693 694
	per_cpu(processors, pr->id) = NULL;
	per_cpu(processor_device_array, pr->id) = NULL;
695 696 697

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

700
	return 0;
L
Linus Torvalds 已提交
701 702 703 704 705 706 707
}

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

L
Len Brown 已提交
708
static int is_processor_present(acpi_handle handle)
L
Linus Torvalds 已提交
709
{
L
Len Brown 已提交
710
	acpi_status status;
711
	unsigned long long sta = 0;
L
Linus Torvalds 已提交
712 713 714


	status = acpi_evaluate_integer(handle, "_STA", NULL, &sta);
715 716 717 718

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

719 720 721 722 723 724 725 726 727
	/*
	 * _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"));
728
	return 0;
L
Linus Torvalds 已提交
729 730 731
}

static
L
Len Brown 已提交
732
int acpi_processor_device_add(acpi_handle handle, struct acpi_device **device)
L
Linus Torvalds 已提交
733
{
L
Len Brown 已提交
734 735
	acpi_handle phandle;
	struct acpi_device *pdev;
L
Linus Torvalds 已提交
736 737 738


	if (acpi_get_parent(handle, &phandle)) {
739
		return -ENODEV;
L
Linus Torvalds 已提交
740 741 742
	}

	if (acpi_bus_get_device(phandle, &pdev)) {
743
		return -ENODEV;
L
Linus Torvalds 已提交
744 745 746
	}

	if (acpi_bus_add(device, pdev, handle, ACPI_BUS_TYPE_PROCESSOR)) {
747
		return -ENODEV;
L
Linus Torvalds 已提交
748 749
	}

750
	return 0;
L
Linus Torvalds 已提交
751 752
}

753 754
static void __ref acpi_processor_hotplug_notify(acpi_handle handle,
						u32 event, void *data)
L
Linus Torvalds 已提交
755
{
L
Len Brown 已提交
756 757
	struct acpi_processor *pr;
	struct acpi_device *device = NULL;
L
Linus Torvalds 已提交
758 759 760 761 762 763
	int result;


	switch (event) {
	case ACPI_NOTIFY_BUS_CHECK:
	case ACPI_NOTIFY_DEVICE_CHECK:
764 765
		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
		"Processor driver received %s event\n",
L
Len Brown 已提交
766
		       (event == ACPI_NOTIFY_BUS_CHECK) ?
767
		       "ACPI_NOTIFY_BUS_CHECK" : "ACPI_NOTIFY_DEVICE_CHECK"));
L
Linus Torvalds 已提交
768 769 770 771 772 773 774

		if (!is_processor_present(handle))
			break;

		if (acpi_bus_get_device(handle, &device)) {
			result = acpi_processor_device_add(handle, &device);
			if (result)
775 776
				printk(KERN_ERR PREFIX
					    "Unable to add the device\n");
L
Linus Torvalds 已提交
777 778
			break;
		}
L
Len Brown 已提交
779
		break;
L
Linus Torvalds 已提交
780
	case ACPI_NOTIFY_EJECT_REQUEST:
L
Len Brown 已提交
781 782
		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
				  "received ACPI_NOTIFY_EJECT_REQUEST\n"));
L
Linus Torvalds 已提交
783 784

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

802
	return;
L
Linus Torvalds 已提交
803 804 805 806
}

static acpi_status
processor_walk_namespace_cb(acpi_handle handle,
L
Len Brown 已提交
807
			    u32 lvl, void *context, void **rv)
L
Linus Torvalds 已提交
808
{
L
Len Brown 已提交
809
	acpi_status status;
L
Linus Torvalds 已提交
810
	int *action = context;
L
Len Brown 已提交
811
	acpi_object_type type = 0;
L
Linus Torvalds 已提交
812 813 814

	status = acpi_get_type(handle, &type);
	if (ACPI_FAILURE(status))
L
Len Brown 已提交
815
		return (AE_OK);
L
Linus Torvalds 已提交
816 817

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

L
Len Brown 已提交
820
	switch (*action) {
L
Linus Torvalds 已提交
821 822
	case INSTALL_NOTIFY_HANDLER:
		acpi_install_notify_handler(handle,
L
Len Brown 已提交
823 824 825
					    ACPI_SYSTEM_NOTIFY,
					    acpi_processor_hotplug_notify,
					    NULL);
L
Linus Torvalds 已提交
826 827 828
		break;
	case UNINSTALL_NOTIFY_HANDLER:
		acpi_remove_notify_handler(handle,
L
Len Brown 已提交
829 830
					   ACPI_SYSTEM_NOTIFY,
					   acpi_processor_hotplug_notify);
L
Linus Torvalds 已提交
831 832 833 834 835
		break;
	default:
		break;
	}

L
Len Brown 已提交
836
	return (AE_OK);
L
Linus Torvalds 已提交
837 838
}

L
Len Brown 已提交
839
static acpi_status acpi_processor_hotadd_init(acpi_handle handle, int *p_cpu)
L
Linus Torvalds 已提交
840 841 842
{

	if (!is_processor_present(handle)) {
843
		return AE_ERROR;
L
Linus Torvalds 已提交
844 845 846
	}

	if (acpi_map_lsapic(handle, p_cpu))
847
		return AE_ERROR;
L
Linus Torvalds 已提交
848 849 850

	if (arch_register_cpu(*p_cpu)) {
		acpi_unmap_lsapic(*p_cpu);
851
		return AE_ERROR;
L
Linus Torvalds 已提交
852 853
	}

854
	return AE_OK;
L
Linus Torvalds 已提交
855 856
}

L
Len Brown 已提交
857
static int acpi_processor_handle_eject(struct acpi_processor *pr)
L
Linus Torvalds 已提交
858
{
859 860 861
	if (cpu_online(pr->id))
		cpu_down(pr->id);

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

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 已提交
896 897
			    ACPI_ROOT_OBJECT,
			    ACPI_UINT32_MAX,
898
			    processor_walk_namespace_cb, NULL, &action, NULL);
L
Linus Torvalds 已提交
899
#endif
900
	unregister_hotcpu_notifier(&acpi_cpu_notifier);
L
Linus Torvalds 已提交
901 902 903 904 905 906 907 908
}

/*
 * 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 已提交
909
static int __init acpi_processor_init(void)
L
Linus Torvalds 已提交
910
{
L
Len Brown 已提交
911
	int result = 0;
L
Linus Torvalds 已提交
912

913 914 915
	if (acpi_disabled)
		return 0;

L
Linus Torvalds 已提交
916 917
	memset(&errata, 0, sizeof(errata));

918
#ifdef CONFIG_ACPI_PROCFS
L
Linus Torvalds 已提交
919 920
	acpi_processor_dir = proc_mkdir(ACPI_PROCESSOR_CLASS, acpi_root_dir);
	if (!acpi_processor_dir)
921
		return -ENOMEM;
922
#endif
923 924 925 926
	result = cpuidle_register_driver(&acpi_idle_driver);
	if (result < 0)
		goto out_proc;

L
Linus Torvalds 已提交
927
	result = acpi_bus_register_driver(&acpi_processor_driver);
928 929
	if (result < 0)
		goto out_cpuidle;
L
Linus Torvalds 已提交
930 931 932 933 934 935 936

	acpi_processor_install_hotplug_notify();

	acpi_thermal_cpufreq_init();

	acpi_processor_ppc_init();

937 938
	acpi_processor_throttling_init();

939
	return 0;
940 941 942 943 944

out_cpuidle:
	cpuidle_unregister_driver(&acpi_idle_driver);

out_proc:
945
#ifdef CONFIG_ACPI_PROCFS
946
	remove_proc_entry(ACPI_PROCESSOR_CLASS, acpi_root_dir);
947
#endif
948 949

	return result;
L
Linus Torvalds 已提交
950 951
}

L
Len Brown 已提交
952
static void __exit acpi_processor_exit(void)
L
Linus Torvalds 已提交
953
{
954 955 956
	if (acpi_disabled)
		return;

L
Linus Torvalds 已提交
957 958 959 960 961 962 963 964
	acpi_processor_ppc_exit();

	acpi_thermal_cpufreq_exit();

	acpi_processor_uninstall_hotplug_notify();

	acpi_bus_unregister_driver(&acpi_processor_driver);

965 966
	cpuidle_unregister_driver(&acpi_idle_driver);

967
#ifdef CONFIG_ACPI_PROCFS
L
Linus Torvalds 已提交
968
	remove_proc_entry(ACPI_PROCESSOR_CLASS, acpi_root_dir);
969
#endif
L
Linus Torvalds 已提交
970

971
	return;
L
Linus Torvalds 已提交
972 973 974 975 976 977 978 979
}

module_init(acpi_processor_init);
module_exit(acpi_processor_exit);

EXPORT_SYMBOL(acpi_processor_set_thermal_limit);

MODULE_ALIAS("processor");