processor_driver.c 25.1 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
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
/*
 * 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/dmi.h>
#include <linux/moduleparam.h>
45
#include <linux/cpuidle.h>
46
#include <linux/slab.h>
Linus Torvalds's avatar
Linus Torvalds committed
47 48 49 50 51 52 53 54 55 56 57 58 59

#include <asm/io.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>

60 61
#define PREFIX "ACPI: "

Linus Torvalds's avatar
Linus Torvalds committed
62 63 64 65 66 67 68
#define ACPI_PROCESSOR_CLASS		"processor"
#define ACPI_PROCESSOR_DEVICE_NAME	"Processor"
#define ACPI_PROCESSOR_FILE_INFO	"info"
#define ACPI_PROCESSOR_FILE_THROTTLING	"throttling"
#define ACPI_PROCESSOR_FILE_LIMIT	"limit"
#define ACPI_PROCESSOR_NOTIFY_PERFORMANCE 0x80
#define ACPI_PROCESSOR_NOTIFY_POWER	0x81
69
#define ACPI_PROCESSOR_NOTIFY_THROTTLING	0x82
70
#define ACPI_PROCESSOR_DEVICE_HID	"ACPI0007"
Linus Torvalds's avatar
Linus Torvalds committed
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_driver");
Linus Torvalds's avatar
Linus Torvalds committed
77

78
MODULE_AUTHOR("Paul Diefenbaugh");
79
MODULE_DESCRIPTION("ACPI Processor Driver");
Linus Torvalds's avatar
Linus Torvalds committed
80 81
MODULE_LICENSE("GPL");

Len Brown's avatar
Len Brown committed
82 83
static int acpi_processor_add(struct acpi_device *device);
static int acpi_processor_remove(struct acpi_device *device, int type);
84
static void acpi_processor_notify(struct acpi_device *device, u32 event);
85
static acpi_status acpi_processor_hotadd_init(struct acpi_processor *pr);
Linus Torvalds's avatar
Linus Torvalds committed
86
static int acpi_processor_handle_eject(struct acpi_processor *pr);
87
static int acpi_processor_start(struct acpi_processor *pr);
Linus Torvalds's avatar
Linus Torvalds committed
88

89
static const struct acpi_device_id processor_device_ids[] = {
90
	{ACPI_PROCESSOR_OBJECT_HID, 0},
91
	{ACPI_PROCESSOR_DEVICE_HID, 0},
92 93 94 95
	{"", 0},
};
MODULE_DEVICE_TABLE(acpi, processor_device_ids);

96 97 98
static SIMPLE_DEV_PM_OPS(acpi_processor_pm,
			 acpi_processor_suspend, acpi_processor_resume);

Linus Torvalds's avatar
Linus Torvalds committed
99
static struct acpi_driver acpi_processor_driver = {
Len Brown's avatar
Len Brown committed
100
	.name = "processor",
Len Brown's avatar
Len Brown committed
101
	.class = ACPI_PROCESSOR_CLASS,
102
	.ids = processor_device_ids,
Len Brown's avatar
Len Brown committed
103 104 105
	.ops = {
		.add = acpi_processor_add,
		.remove = acpi_processor_remove,
106
		.notify = acpi_processor_notify,
Len Brown's avatar
Len Brown committed
107
		},
108
	.drv.pm = &acpi_processor_pm,
Linus Torvalds's avatar
Linus Torvalds committed
109 110 111 112 113
};

#define INSTALL_NOTIFY_HANDLER		1
#define UNINSTALL_NOTIFY_HANDLER	2

114
DEFINE_PER_CPU(struct acpi_processor *, processors);
115 116
EXPORT_PER_CPU_SYMBOL(processors);

117
struct acpi_processor_errata errata __read_mostly;
Linus Torvalds's avatar
Linus Torvalds committed
118 119 120 121 122

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

Len Brown's avatar
Len Brown committed
123
static int acpi_processor_errata_piix4(struct pci_dev *dev)
Linus Torvalds's avatar
Linus Torvalds committed
124
{
Len Brown's avatar
Len Brown committed
125 126
	u8 value1 = 0;
	u8 value2 = 0;
Linus Torvalds's avatar
Linus Torvalds committed
127 128 129


	if (!dev)
130
		return -EINVAL;
Linus Torvalds's avatar
Linus Torvalds committed
131 132 133 134 135

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

136
	switch (dev->revision) {
Linus Torvalds's avatar
Linus Torvalds committed
137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153
	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;
	}

154
	switch (dev->revision) {
Linus Torvalds's avatar
Linus Torvalds committed
155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183

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

221
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
222 223
}

224
static int acpi_processor_errata(struct acpi_processor *pr)
Linus Torvalds's avatar
Linus Torvalds committed
225
{
Len Brown's avatar
Len Brown committed
226 227
	int result = 0;
	struct pci_dev *dev = NULL;
Linus Torvalds's avatar
Linus Torvalds committed
228 229 230


	if (!pr)
231
		return -EINVAL;
Linus Torvalds's avatar
Linus Torvalds committed
232 233 234 235 236

	/*
	 * PIIX4
	 */
	dev = pci_get_subsys(PCI_VENDOR_ID_INTEL,
Len Brown's avatar
Len Brown committed
237 238
			     PCI_DEVICE_ID_INTEL_82371AB_3, PCI_ANY_ID,
			     PCI_ANY_ID, NULL);
Linus Torvalds's avatar
Linus Torvalds committed
239 240 241 242 243
	if (dev) {
		result = acpi_processor_errata_piix4(dev);
		pci_dev_put(dev);
	}

244
	return result;
Linus Torvalds's avatar
Linus Torvalds committed
245 246 247 248 249 250
}

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

251
static int acpi_processor_get_info(struct acpi_device *device)
Linus Torvalds's avatar
Linus Torvalds committed
252
{
Len Brown's avatar
Len Brown committed
253 254 255
	acpi_status status = 0;
	union acpi_object object = { 0 };
	struct acpi_buffer buffer = { sizeof(union acpi_object), &object };
256 257
	struct acpi_processor *pr;
	int cpu_index, device_declaration = 0;
Len Brown's avatar
Len Brown committed
258
	static int cpu0_initialized;
Linus Torvalds's avatar
Linus Torvalds committed
259

260
	pr = acpi_driver_data(device);
Linus Torvalds's avatar
Linus Torvalds committed
261
	if (!pr)
262
		return -EINVAL;
Linus Torvalds's avatar
Linus Torvalds committed
263 264 265 266 267 268 269 270 271 272

	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).
	 */
273
	if (acpi_gbl_FADT.pm2_control_block && acpi_gbl_FADT.pm2_control_length) {
Linus Torvalds's avatar
Linus Torvalds committed
274 275
		pr->flags.bm_control = 1;
		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
Len Brown's avatar
Len Brown committed
276 277
				  "Bus mastering arbitration control present\n"));
	} else
Linus Torvalds's avatar
Linus Torvalds committed
278
		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
Len Brown's avatar
Len Brown committed
279
				  "No bus mastering arbitration control\n"));
Linus Torvalds's avatar
Linus Torvalds committed
280

281 282 283 284 285 286 287 288 289 290 291 292 293 294 295
	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 {
296 297 298 299
		/*
		 * Declared with "Device" statement; match _UID.
		 * Note that we don't handle string _UIDs yet.
		 */
300
		unsigned long long value;
301 302 303
		status = acpi_evaluate_integer(pr->handle, METHOD_NAME__UID,
						NULL, &value);
		if (ACPI_FAILURE(status)) {
304 305
			printk(KERN_ERR PREFIX
			    "Evaluating processor _UID [%#x]\n", status);
306 307
			return -ENODEV;
		}
308
		device_declaration = 1;
309 310
		pr->acpi_id = value;
	}
311
	cpu_index = acpi_get_cpuid(pr->handle, device_declaration, pr->acpi_id);
Linus Torvalds's avatar
Linus Torvalds committed
312

Len Brown's avatar
Len Brown committed
313
	/* Handle UP system running SMP kernel, with no LAPIC in MADT */
Ashok Raj's avatar
Ashok Raj committed
314
	if (!cpu0_initialized && (cpu_index == -1) &&
Len Brown's avatar
Len Brown committed
315 316 317 318 319 320 321 322 323 324 325 326 327
	    (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.
	 */
328
	if (pr->id == -1) {
329
		if (ACPI_FAILURE(acpi_processor_hotadd_init(pr)))
330
			return -ENODEV;
Len Brown's avatar
Len Brown committed
331
	}
332 333 334 335 336 337 338 339 340 341
	/*
	 * 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);
Linus Torvalds's avatar
Linus Torvalds committed
342
	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Processor [%d:%d]\n", pr->id,
Len Brown's avatar
Len Brown committed
343
			  pr->acpi_id));
Linus Torvalds's avatar
Linus Torvalds committed
344 345 346 347

	if (!object.processor.pblk_address)
		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No PBLK (NULL address)\n"));
	else if (object.processor.pblk_length != 6)
348 349
		printk(KERN_ERR PREFIX "Invalid PBLK length [%d]\n",
			    object.processor.pblk_length);
Linus Torvalds's avatar
Linus Torvalds committed
350 351
	else {
		pr->throttling.address = object.processor.pblk_address;
352 353
		pr->throttling.duty_offset = acpi_gbl_FADT.duty_offset;
		pr->throttling.duty_width = acpi_gbl_FADT.duty_width;
Linus Torvalds's avatar
Linus Torvalds committed
354 355 356 357 358 359 360 361 362 363 364 365 366

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

367 368 369 370 371 372 373 374 375
	/*
	 * 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);

376
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
377 378
}

379
static DEFINE_PER_CPU(void *, processor_device_array);
380

381
static void acpi_processor_notify(struct acpi_device *device, u32 event)
Linus Torvalds's avatar
Linus Torvalds committed
382
{
383
	struct acpi_processor *pr = acpi_driver_data(device);
384
	int saved;
Linus Torvalds's avatar
Linus Torvalds committed
385 386

	if (!pr)
387
		return;
Linus Torvalds's avatar
Linus Torvalds committed
388 389 390

	switch (event) {
	case ACPI_PROCESSOR_NOTIFY_PERFORMANCE:
391
		saved = pr->performance_platform_limit;
392
		acpi_processor_ppc_has_changed(pr, 1);
393 394
		if (saved == pr->performance_platform_limit)
			break;
395
		acpi_bus_generate_proc_event(device, event,
Len Brown's avatar
Len Brown committed
396
					pr->performance_platform_limit);
397
		acpi_bus_generate_netlink_event(device->pnp.device_class,
398
						  dev_name(&device->dev), event,
399
						  pr->performance_platform_limit);
Linus Torvalds's avatar
Linus Torvalds committed
400 401 402
		break;
	case ACPI_PROCESSOR_NOTIFY_POWER:
		acpi_processor_cst_has_changed(pr);
403
		acpi_bus_generate_proc_event(device, event, 0);
404
		acpi_bus_generate_netlink_event(device->pnp.device_class,
405
						  dev_name(&device->dev), event, 0);
Linus Torvalds's avatar
Linus Torvalds committed
406
		break;
407 408
	case ACPI_PROCESSOR_NOTIFY_THROTTLING:
		acpi_processor_tstate_has_changed(pr);
409
		acpi_bus_generate_proc_event(device, event, 0);
410
		acpi_bus_generate_netlink_event(device->pnp.device_class,
411
						  dev_name(&device->dev), event, 0);
Alan Cox's avatar
Alan Cox committed
412
		break;
Linus Torvalds's avatar
Linus Torvalds committed
413 414
	default:
		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
Len Brown's avatar
Len Brown committed
415
				  "Unsupported event [0x%x]\n", event));
Linus Torvalds's avatar
Linus Torvalds committed
416 417 418
		break;
	}

419
	return;
Linus Torvalds's avatar
Linus Torvalds committed
420 421
}

422 423 424 425
static int acpi_cpu_soft_notify(struct notifier_block *nfb,
		unsigned long action, void *hcpu)
{
	unsigned int cpu = (unsigned long)hcpu;
426
	struct acpi_processor *pr = per_cpu(processors, cpu);
427 428

	if (action == CPU_ONLINE && pr) {
429 430 431 432 433 434 435 436 437 438 439 440
		/* CPU got physically hotplugged and onlined the first time:
		 * Initialize missing things
		 */
		if (pr->flags.need_hotplug_init) {
			printk(KERN_INFO "Will online and init hotplugged "
			       "CPU: %d\n", pr->id);
			WARN(acpi_processor_start(pr), "Failed to start CPU:"
				" %d\n", pr->id);
			pr->flags.need_hotplug_init = 0;
		/* Normal CPU soft online event */
		} else {
			acpi_processor_ppc_has_changed(pr, 0);
441
			acpi_processor_hotplug(pr);
442 443 444
			acpi_processor_reevaluate_tstate(pr, action);
			acpi_processor_tstate_has_changed(pr);
		}
445
	}
446 447 448 449
	if (action == CPU_DEAD && pr) {
		/* invalidate the flag.throttling after one CPU is offline */
		acpi_processor_reevaluate_tstate(pr, action);
	}
450 451 452 453 454 455 456 457
	return NOTIFY_OK;
}

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

458 459 460 461 462 463 464 465 466
/*
 * acpi_processor_start() is called by the cpu_hotplug_notifier func:
 * acpi_cpu_soft_notify(). Getting it __cpuinit{data} is difficult, the
 * root cause seem to be that acpi_processor_uninstall_hotplug_notify()
 * is in the module_exit (__exit) func. Allowing acpi_processor_start()
 * to not be in __cpuinit section, but being called from __cpuinit funcs
 * via __ref looks like the right thing to do here.
 */
static __ref int acpi_processor_start(struct acpi_processor *pr)
467 468 469 470 471 472
{
	struct acpi_device *device = per_cpu(processor_device_array, pr->id);
	int result = 0;

#ifdef CONFIG_CPU_FREQ
	acpi_processor_ppc_has_changed(pr, 0);
473
	acpi_processor_load_module(pr);
474 475 476 477 478
#endif
	acpi_processor_get_throttling_info(pr);
	acpi_processor_get_limit_info(pr);

	if (!cpuidle_get_driver() || cpuidle_get_driver() == &acpi_idle_driver)
479
		acpi_processor_power_init(pr);
480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512

	pr->cdev = thermal_cooling_device_register("Processor", device,
						   &processor_cooling_ops);
	if (IS_ERR(pr->cdev)) {
		result = PTR_ERR(pr->cdev);
		goto err_power_exit;
	}

	dev_dbg(&device->dev, "registered as cooling_device%d\n",
		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");
		goto err_thermal_unregister;
	}
	result = sysfs_create_link(&pr->cdev->device.kobj,
				   &device->dev.kobj,
				   "device");
	if (result) {
		printk(KERN_ERR PREFIX "Create sysfs link\n");
		goto err_remove_sysfs_thermal;
	}

	return 0;

err_remove_sysfs_thermal:
	sysfs_remove_link(&device->dev.kobj, "thermal_cooling");
err_thermal_unregister:
	thermal_cooling_device_unregister(pr->cdev);
err_power_exit:
513
	acpi_processor_power_exit(pr);
514 515 516 517

	return result;
}

518 519 520 521 522 523
/*
 * Do not put anything in here which needs the core to be online.
 * For example MSR access or setting up things which check for cpuinfo_x86
 * (cpu_data(cpu)) values, like CPU feature flags, family, model, etc.
 * Such things have to be put in and set up above in acpi_processor_start()
 */
524
static int __cpuinit acpi_processor_add(struct acpi_device *device)
Linus Torvalds's avatar
Linus Torvalds committed
525
{
Len Brown's avatar
Len Brown committed
526
	struct acpi_processor *pr = NULL;
527
	int result = 0;
528
	struct device *dev;
Linus Torvalds's avatar
Linus Torvalds committed
529

530
	pr = kzalloc(sizeof(struct acpi_processor), GFP_KERNEL);
Linus Torvalds's avatar
Linus Torvalds committed
531
	if (!pr)
532
		return -ENOMEM;
Linus Torvalds's avatar
Linus Torvalds committed
533

534
	if (!zalloc_cpumask_var(&pr->throttling.shared_cpu_map, GFP_KERNEL)) {
535 536
		result = -ENOMEM;
		goto err_free_pr;
537 538
	}

Linus Torvalds's avatar
Linus Torvalds committed
539 540 541
	pr->handle = device->handle;
	strcpy(acpi_device_name(device), ACPI_PROCESSOR_DEVICE_NAME);
	strcpy(acpi_device_class(device), ACPI_PROCESSOR_CLASS);
542
	device->driver_data = pr;
Linus Torvalds's avatar
Linus Torvalds committed
543

544
	result = acpi_processor_get_info(device);
Linus Torvalds's avatar
Linus Torvalds committed
545 546
	if (result) {
		/* Processor is physically not present */
547
		return 0;
Linus Torvalds's avatar
Linus Torvalds committed
548 549
	}

550 551 552 553 554
#ifdef CONFIG_SMP
	if (pr->id >= setup_max_cpus && pr->id != 0)
		return 0;
#endif

555
	BUG_ON((pr->id >= nr_cpu_ids) || (pr->id < 0));
Linus Torvalds's avatar
Linus Torvalds committed
556

557 558 559 560 561
	/*
	 * Buggy BIOS check
	 * ACPI id of processors can be reported wrongly by the BIOS.
	 * Don't trust it blindly
	 */
562 563
	if (per_cpu(processor_device_array, pr->id) != NULL &&
	    per_cpu(processor_device_array, pr->id) != device) {
564
		printk(KERN_WARNING "BIOS reported wrong ACPI id "
Len Brown's avatar
Len Brown committed
565
			"for the processor\n");
566 567
		result = -ENODEV;
		goto err_free_cpumask;
568
	}
569
	per_cpu(processor_device_array, pr->id) = device;
570

571
	per_cpu(processors, pr->id) = pr;
Linus Torvalds's avatar
Linus Torvalds committed
572

573 574
	dev = get_cpu_device(pr->id);
	if (sysfs_create_link(&device->dev.kobj, &dev->kobj, "sysdev")) {
575
		result = -EFAULT;
576
		goto err_clear_processor;
577
	}
578

579 580 581 582 583 584
	/*
	 * Do not start hotplugged CPUs now, but when they
	 * are onlined the first time
	 */
	if (pr->flags.need_hotplug_init)
		return 0;
585

586 587
	result = acpi_processor_start(pr);
	if (result)
588
		goto err_remove_sysfs;
589

590
	return 0;
591 592

err_remove_sysfs:
593
	sysfs_remove_link(&device->dev.kobj, "sysdev");
594 595 596 597 598
err_clear_processor:
	/*
	 * processor_device_array is not cleared to allow checks for buggy BIOS
	 */ 
	per_cpu(processors, pr->id) = NULL;
599 600
err_free_cpumask:
	free_cpumask_var(pr->throttling.shared_cpu_map);
601 602
err_free_pr:
	kfree(pr);
603
	return result;
Linus Torvalds's avatar
Linus Torvalds committed
604 605
}

Len Brown's avatar
Len Brown committed
606
static int acpi_processor_remove(struct acpi_device *device, int type)
Linus Torvalds's avatar
Linus Torvalds committed
607
{
Len Brown's avatar
Len Brown committed
608
	struct acpi_processor *pr = NULL;
Linus Torvalds's avatar
Linus Torvalds committed
609 610 611


	if (!device || !acpi_driver_data(device))
612
		return -EINVAL;
Linus Torvalds's avatar
Linus Torvalds committed
613

614
	pr = acpi_driver_data(device);
Linus Torvalds's avatar
Linus Torvalds committed
615

616 617
	if (pr->id >= nr_cpu_ids)
		goto free;
Linus Torvalds's avatar
Linus Torvalds committed
618 619 620

	if (type == ACPI_BUS_REMOVAL_EJECT) {
		if (acpi_processor_handle_eject(pr))
621
			return -EINVAL;
Linus Torvalds's avatar
Linus Torvalds committed
622 623
	}

624
	acpi_processor_power_exit(pr);
Linus Torvalds's avatar
Linus Torvalds committed
625

626 627
	sysfs_remove_link(&device->dev.kobj, "sysdev");

628 629 630 631 632 633
	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;
	}
634

635 636
	per_cpu(processors, pr->id) = NULL;
	per_cpu(processor_device_array, pr->id) = NULL;
637 638 639

free:
	free_cpumask_var(pr->throttling.shared_cpu_map);
Linus Torvalds's avatar
Linus Torvalds committed
640 641
	kfree(pr);

642
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
643 644 645 646 647 648 649
}

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

Len Brown's avatar
Len Brown committed
650
static int is_processor_present(acpi_handle handle)
Linus Torvalds's avatar
Linus Torvalds committed
651
{
Len Brown's avatar
Len Brown committed
652
	acpi_status status;
653
	unsigned long long sta = 0;
Linus Torvalds's avatar
Linus Torvalds committed
654 655 656


	status = acpi_evaluate_integer(handle, "_STA", NULL, &sta);
657 658 659 660

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

661 662 663 664 665 666 667 668 669
	/*
	 * _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"));
670
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
671 672 673
}

static
Len Brown's avatar
Len Brown committed
674
int acpi_processor_device_add(acpi_handle handle, struct acpi_device **device)
Linus Torvalds's avatar
Linus Torvalds committed
675
{
Len Brown's avatar
Len Brown committed
676 677
	acpi_handle phandle;
	struct acpi_device *pdev;
Linus Torvalds's avatar
Linus Torvalds committed
678 679 680


	if (acpi_get_parent(handle, &phandle)) {
681
		return -ENODEV;
Linus Torvalds's avatar
Linus Torvalds committed
682 683 684
	}

	if (acpi_bus_get_device(phandle, &pdev)) {
685
		return -ENODEV;
Linus Torvalds's avatar
Linus Torvalds committed
686 687 688
	}

	if (acpi_bus_add(device, pdev, handle, ACPI_BUS_TYPE_PROCESSOR)) {
689
		return -ENODEV;
Linus Torvalds's avatar
Linus Torvalds committed
690 691
	}

692
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
693 694
}

695 696
static void acpi_processor_hotplug_notify(acpi_handle handle,
					  u32 event, void *data)
Linus Torvalds's avatar
Linus Torvalds committed
697
{
Len Brown's avatar
Len Brown committed
698
	struct acpi_device *device = NULL;
699
	struct acpi_eject_event *ej_event = NULL;
700
	u32 ost_code = ACPI_OST_SC_NON_SPECIFIC_FAILURE; /* default */
Linus Torvalds's avatar
Linus Torvalds committed
701 702 703 704 705
	int result;

	switch (event) {
	case ACPI_NOTIFY_BUS_CHECK:
	case ACPI_NOTIFY_DEVICE_CHECK:
706 707
		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
		"Processor driver received %s event\n",
Len Brown's avatar
Len Brown committed
708
		       (event == ACPI_NOTIFY_BUS_CHECK) ?
709
		       "ACPI_NOTIFY_BUS_CHECK" : "ACPI_NOTIFY_DEVICE_CHECK"));
Linus Torvalds's avatar
Linus Torvalds committed
710 711 712 713

		if (!is_processor_present(handle))
			break;

714 715 716 717 718 719
		if (!acpi_bus_get_device(handle, &device))
			break;

		result = acpi_processor_device_add(handle, &device);
		if (result) {
			printk(KERN_ERR PREFIX "Unable to add the device\n");
Linus Torvalds's avatar
Linus Torvalds committed
720 721
			break;
		}
722 723

		ost_code = ACPI_OST_SC_SUCCESS;
Len Brown's avatar
Len Brown committed
724
		break;
725

Linus Torvalds's avatar
Linus Torvalds committed
726
	case ACPI_NOTIFY_EJECT_REQUEST:
Len Brown's avatar
Len Brown committed
727 728
		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
				  "received ACPI_NOTIFY_EJECT_REQUEST\n"));
Linus Torvalds's avatar
Linus Torvalds committed
729 730

		if (acpi_bus_get_device(handle, &device)) {
731
			pr_err(PREFIX "Device don't exist, dropping EJECT\n");
Linus Torvalds's avatar
Linus Torvalds committed
732 733
			break;
		}
734 735
		if (!acpi_driver_data(device)) {
			pr_err(PREFIX "Driver data is NULL, dropping EJECT\n");
736
			break;
Linus Torvalds's avatar
Linus Torvalds committed
737
		}
738

739 740 741 742 743 744 745 746 747 748 749 750 751
		ej_event = kmalloc(sizeof(*ej_event), GFP_KERNEL);
		if (!ej_event) {
			pr_err(PREFIX "No memory, dropping EJECT\n");
			break;
		}

		ej_event->handle = handle;
		ej_event->event = ACPI_NOTIFY_EJECT_REQUEST;
		acpi_os_hotplug_execute(acpi_bus_hot_remove_device,
					(void *)ej_event);

		/* eject is performed asynchronously */
		return;
752

Linus Torvalds's avatar
Linus Torvalds committed
753 754
	default:
		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
Len Brown's avatar
Len Brown committed
755
				  "Unsupported event [0x%x]\n", event));
756 757 758

		/* non-hotplug event; possibly handled by other handler */
		return;
Linus Torvalds's avatar
Linus Torvalds committed
759 760
	}

761 762
	/* Inform firmware that the hotplug operation has completed */
	(void) acpi_evaluate_hotplug_ost(handle, event, ost_code, NULL);
763
	return;
Linus Torvalds's avatar
Linus Torvalds committed
764 765
}

766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795
static acpi_status is_processor_device(acpi_handle handle)
{
	struct acpi_device_info *info;
	char *hid;
	acpi_status status;

	status = acpi_get_object_info(handle, &info);
	if (ACPI_FAILURE(status))
		return status;

	if (info->type == ACPI_TYPE_PROCESSOR) {
		kfree(info);
		return AE_OK;	/* found a processor object */
	}

	if (!(info->valid & ACPI_VALID_HID)) {
		kfree(info);
		return AE_ERROR;
	}

	hid = info->hardware_id.string;
	if ((hid == NULL) || strcmp(hid, ACPI_PROCESSOR_DEVICE_HID)) {
		kfree(info);
		return AE_ERROR;
	}

	kfree(info);
	return AE_OK;	/* found a processor device object */
}

Linus Torvalds's avatar
Linus Torvalds committed
796 797
static acpi_status
processor_walk_namespace_cb(acpi_handle handle,
Len Brown's avatar
Len Brown committed
798
			    u32 lvl, void *context, void **rv)
Linus Torvalds's avatar
Linus Torvalds committed
799
{
Len Brown's avatar
Len Brown committed
800
	acpi_status status;
Linus Torvalds's avatar
Linus Torvalds committed
801 802
	int *action = context;

803
	status = is_processor_device(handle);
Linus Torvalds's avatar
Linus Torvalds committed
804
	if (ACPI_FAILURE(status))
805
		return AE_OK;	/* not a processor; continue to walk */
Linus Torvalds's avatar
Linus Torvalds committed
806

Len Brown's avatar
Len Brown committed
807
	switch (*action) {
Linus Torvalds's avatar
Linus Torvalds committed
808 809
	case INSTALL_NOTIFY_HANDLER:
		acpi_install_notify_handler(handle,
Len Brown's avatar
Len Brown committed
810 811 812
					    ACPI_SYSTEM_NOTIFY,
					    acpi_processor_hotplug_notify,
					    NULL);
Linus Torvalds's avatar
Linus Torvalds committed
813 814 815
		break;
	case UNINSTALL_NOTIFY_HANDLER:
		acpi_remove_notify_handler(handle,
Len Brown's avatar
Len Brown committed
816 817
					   ACPI_SYSTEM_NOTIFY,
					   acpi_processor_hotplug_notify);
Linus Torvalds's avatar
Linus Torvalds committed
818 819 820 821 822
		break;
	default:
		break;
	}

823 824
	/* found a processor; skip walking underneath */
	return AE_CTRL_DEPTH;
Linus Torvalds's avatar
Linus Torvalds committed
825 826
}

827
static acpi_status acpi_processor_hotadd_init(struct acpi_processor *pr)
Linus Torvalds's avatar
Linus Torvalds committed
828
{
829
	acpi_handle handle = pr->handle;
Linus Torvalds's avatar
Linus Torvalds committed
830 831

	if (!is_processor_present(handle)) {
832
		return AE_ERROR;
Linus Torvalds's avatar
Linus Torvalds committed
833 834
	}

835
	if (acpi_map_lsapic(handle, &pr->id))
836
		return AE_ERROR;
Linus Torvalds's avatar
Linus Torvalds committed
837

838 839
	if (arch_register_cpu(pr->id)) {
		acpi_unmap_lsapic(pr->id);
840
		return AE_ERROR;
Linus Torvalds's avatar
Linus Torvalds committed
841 842
	}

843 844 845 846 847 848 849 850 851 852 853
	/* CPU got hot-plugged, but cpu_data is not initialized yet
	 * Set flag to delay cpu_idle/throttling initialization
	 * in:
	 * acpi_processor_add()
	 *   acpi_processor_get_info()
	 * and do it when the CPU gets online the first time
	 * TBD: Cleanup above functions and try to do this more elegant.
	 */
	printk(KERN_INFO "CPU %d got hotplugged\n", pr->id);
	pr->flags.need_hotplug_init = 1;

854
	return AE_OK;
Linus Torvalds's avatar
Linus Torvalds committed
855 856
}

Len Brown's avatar
Len Brown committed
857
static int acpi_processor_handle_eject(struct acpi_processor *pr)
Linus Torvalds's avatar
Linus Torvalds committed
858
{
859 860 861
	if (cpu_online(pr->id))
		cpu_down(pr->id);

862 863 864 865 866 867 868 869 870 871 872 873 874
	get_online_cpus();
	/*
	 * The cpu might become online again at this point. So we check whether
	 * the cpu has been onlined or not. If the cpu became online, it means
	 * that someone wants to use the cpu. So acpi_processor_handle_eject()
	 * returns -EAGAIN.
	 */
	if (unlikely(cpu_online(pr->id))) {
		put_online_cpus();
		pr_warn("Failed to remove CPU %d, because other task "
			"brought the CPU back online\n", pr->id);
		return -EAGAIN;
	}
Linus Torvalds's avatar
Linus Torvalds committed
875 876
	arch_unregister_cpu(pr->id);
	acpi_unmap_lsapic(pr->id);
877
	put_online_cpus();
Len Brown's avatar
Len Brown committed
878
	return (0);
Linus Torvalds's avatar
Linus Torvalds committed
879 880
}
#else
881
static acpi_status acpi_processor_hotadd_init(struct acpi_processor *pr)
Linus Torvalds's avatar
Linus Torvalds committed
882 883 884
{
	return AE_ERROR;
}
Len Brown's avatar
Len Brown committed
885
static int acpi_processor_handle_eject(struct acpi_processor *pr)
Linus Torvalds's avatar
Linus Torvalds committed
886
{
Len Brown's avatar
Len Brown committed
887
	return (-EINVAL);
Linus Torvalds's avatar
Linus Torvalds committed
888 889 890 891 892 893 894 895
}
#endif

static
void acpi_processor_install_hotplug_notify(void)
{
#ifdef CONFIG_ACPI_HOTPLUG_CPU
	int action = INSTALL_NOTIFY_HANDLER;
896
	acpi_walk_namespace(ACPI_TYPE_ANY,
Len Brown's avatar
Len Brown committed
897 898
			    ACPI_ROOT_OBJECT,
			    ACPI_UINT32_MAX,
899
			    processor_walk_namespace_cb, NULL, &action, NULL);
Linus Torvalds's avatar
Linus Torvalds committed
900
#endif
901
	register_hotcpu_notifier(&acpi_cpu_notifier);
Linus Torvalds's avatar
Linus Torvalds committed
902 903 904 905 906 907 908
}

static
void acpi_processor_uninstall_hotplug_notify(void)
{
#ifdef CONFIG_ACPI_HOTPLUG_CPU
	int action = UNINSTALL_NOTIFY_HANDLER;
909
	acpi_walk_namespace(ACPI_TYPE_ANY,
Len Brown's avatar
Len Brown committed
910 911
			    ACPI_ROOT_OBJECT,
			    ACPI_UINT32_MAX,
912
			    processor_walk_namespace_cb, NULL, &action, NULL);
Linus Torvalds's avatar
Linus Torvalds committed
913
#endif
914
	unregister_hotcpu_notifier(&acpi_cpu_notifier);
Linus Torvalds's avatar
Linus Torvalds committed
915 916 917 918 919 920 921 922
}

/*
 * 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
 */

Len Brown's avatar
Len Brown committed
923
static int __init acpi_processor_init(void)
Linus Torvalds's avatar
Linus Torvalds committed
924
{
Len Brown's avatar
Len Brown committed
925
	int result = 0;
Linus Torvalds's avatar
Linus Torvalds committed
926

927 928 929
	if (acpi_disabled)
		return 0;

Linus Torvalds's avatar
Linus Torvalds committed
930
	result = acpi_bus_register_driver(&acpi_processor_driver);
931
	if (result < 0)
932
		return result;
Linus Torvalds's avatar
Linus Torvalds committed
933 934 935 936 937 938 939

	acpi_processor_install_hotplug_notify();

	acpi_thermal_cpufreq_init();

	acpi_processor_ppc_init();

940 941
	acpi_processor_throttling_init();

942
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
943 944
}

Len Brown's avatar
Len Brown committed
945
static void __exit acpi_processor_exit(void)
Linus Torvalds's avatar
Linus Torvalds committed
946
{
947 948 949
	if (acpi_disabled)
		return;

Linus Torvalds's avatar
Linus Torvalds committed
950 951 952 953 954 955 956 957
	acpi_processor_ppc_exit();

	acpi_thermal_cpufreq_exit();

	acpi_processor_uninstall_hotplug_notify();

	acpi_bus_unregister_driver(&acpi_processor_driver);

958
	return;
Linus Torvalds's avatar
Linus Torvalds committed
959 960 961 962 963 964
}

module_init(acpi_processor_init);
module_exit(acpi_processor_exit);

MODULE_ALIAS("processor");