1 /*
2  * acpi_processor.c - ACPI Processor Driver ($Revision: 71 $)
3  *
4  *  Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
5  *  Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
6  *  Copyright (C) 2004       Dominik Brodowski <linux@brodo.de>
7  *  Copyright (C) 2004  Anil S Keshavamurthy <anil.s.keshavamurthy@intel.com>
8  *  			- Added processor hotplug support
9  *
10  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
11  *
12  *  This program is free software; you can redistribute it and/or modify
13  *  it under the terms of the GNU General Public License as published by
14  *  the Free Software Foundation; either version 2 of the License, or (at
15  *  your option) any later version.
16  *
17  *  This program is distributed in the hope that it will be useful, but
18  *  WITHOUT ANY WARRANTY; without even the implied warranty of
19  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
20  *  General Public License for more details.
21  *
22  *  You should have received a copy of the GNU General Public License along
23  *  with this program; if not, write to the Free Software Foundation, Inc.,
24  *  59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
25  *
26  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
27  *  TBD:
28  *	1. Make # power states dynamic.
29  *	2. Support duty_cycle values that span bit 4.
30  *	3. Optimize by having scheduler determine business instead of
31  *	   having us try to calculate it here.
32  *	4. Need C1 timing -- must modify kernel (IRQ handler) to get this.
33  */
34 
35 #include <linux/kernel.h>
36 #include <linux/module.h>
37 #include <linux/init.h>
38 #include <linux/types.h>
39 #include <linux/pci.h>
40 #include <linux/pm.h>
41 #include <linux/cpufreq.h>
42 #include <linux/cpu.h>
43 #include <linux/dmi.h>
44 #include <linux/moduleparam.h>
45 #include <linux/cpuidle.h>
46 #include <linux/slab.h>
47 
48 #include <asm/io.h>
49 #include <asm/cpu.h>
50 #include <asm/delay.h>
51 #include <asm/uaccess.h>
52 #include <asm/processor.h>
53 #include <asm/smp.h>
54 #include <asm/acpi.h>
55 
56 #include <acpi/acpi_bus.h>
57 #include <acpi/acpi_drivers.h>
58 #include <acpi/processor.h>
59 
60 #define PREFIX "ACPI: "
61 
62 #define ACPI_PROCESSOR_CLASS		"processor"
63 #define ACPI_PROCESSOR_DEVICE_NAME	"Processor"
64 #define ACPI_PROCESSOR_FILE_INFO	"info"
65 #define ACPI_PROCESSOR_FILE_THROTTLING	"throttling"
66 #define ACPI_PROCESSOR_FILE_LIMIT	"limit"
67 #define ACPI_PROCESSOR_NOTIFY_PERFORMANCE 0x80
68 #define ACPI_PROCESSOR_NOTIFY_POWER	0x81
69 #define ACPI_PROCESSOR_NOTIFY_THROTTLING	0x82
70 
71 #define ACPI_PROCESSOR_LIMIT_USER	0
72 #define ACPI_PROCESSOR_LIMIT_THERMAL	1
73 
74 #define _COMPONENT		ACPI_PROCESSOR_COMPONENT
75 ACPI_MODULE_NAME("processor_driver");
76 
77 MODULE_AUTHOR("Paul Diefenbaugh");
78 MODULE_DESCRIPTION("ACPI Processor Driver");
79 MODULE_LICENSE("GPL");
80 
81 static int acpi_processor_add(struct acpi_device *device);
82 static int acpi_processor_remove(struct acpi_device *device, int type);
83 static void acpi_processor_notify(struct acpi_device *device, u32 event);
84 static acpi_status acpi_processor_hotadd_init(struct acpi_processor *pr);
85 static int acpi_processor_handle_eject(struct acpi_processor *pr);
86 static int acpi_processor_start(struct acpi_processor *pr);
87 
88 static const struct acpi_device_id processor_device_ids[] = {
89 	{ACPI_PROCESSOR_OBJECT_HID, 0},
90 	{"ACPI0007", 0},
91 	{"", 0},
92 };
93 MODULE_DEVICE_TABLE(acpi, processor_device_ids);
94 
95 static struct acpi_driver acpi_processor_driver = {
96 	.name = "processor",
97 	.class = ACPI_PROCESSOR_CLASS,
98 	.ids = processor_device_ids,
99 	.ops = {
100 		.add = acpi_processor_add,
101 		.remove = acpi_processor_remove,
102 		.suspend = acpi_processor_suspend,
103 		.resume = acpi_processor_resume,
104 		.notify = acpi_processor_notify,
105 		},
106 };
107 
108 #define INSTALL_NOTIFY_HANDLER		1
109 #define UNINSTALL_NOTIFY_HANDLER	2
110 
111 DEFINE_PER_CPU(struct acpi_processor *, processors);
112 EXPORT_PER_CPU_SYMBOL(processors);
113 
114 struct acpi_processor_errata errata __read_mostly;
115 
116 /* --------------------------------------------------------------------------
117                                 Errata Handling
118    -------------------------------------------------------------------------- */
119 
120 static int acpi_processor_errata_piix4(struct pci_dev *dev)
121 {
122 	u8 value1 = 0;
123 	u8 value2 = 0;
124 
125 
126 	if (!dev)
127 		return -EINVAL;
128 
129 	/*
130 	 * Note that 'dev' references the PIIX4 ACPI Controller.
131 	 */
132 
133 	switch (dev->revision) {
134 	case 0:
135 		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found PIIX4 A-step\n"));
136 		break;
137 	case 1:
138 		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found PIIX4 B-step\n"));
139 		break;
140 	case 2:
141 		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found PIIX4E\n"));
142 		break;
143 	case 3:
144 		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found PIIX4M\n"));
145 		break;
146 	default:
147 		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found unknown PIIX4\n"));
148 		break;
149 	}
150 
151 	switch (dev->revision) {
152 
153 	case 0:		/* PIIX4 A-step */
154 	case 1:		/* PIIX4 B-step */
155 		/*
156 		 * See specification changes #13 ("Manual Throttle Duty Cycle")
157 		 * and #14 ("Enabling and Disabling Manual Throttle"), plus
158 		 * erratum #5 ("STPCLK# Deassertion Time") from the January
159 		 * 2002 PIIX4 specification update.  Applies to only older
160 		 * PIIX4 models.
161 		 */
162 		errata.piix4.throttle = 1;
163 
164 	case 2:		/* PIIX4E */
165 	case 3:		/* PIIX4M */
166 		/*
167 		 * See erratum #18 ("C3 Power State/BMIDE and Type-F DMA
168 		 * Livelock") from the January 2002 PIIX4 specification update.
169 		 * Applies to all PIIX4 models.
170 		 */
171 
172 		/*
173 		 * BM-IDE
174 		 * ------
175 		 * Find the PIIX4 IDE Controller and get the Bus Master IDE
176 		 * Status register address.  We'll use this later to read
177 		 * each IDE controller's DMA status to make sure we catch all
178 		 * DMA activity.
179 		 */
180 		dev = pci_get_subsys(PCI_VENDOR_ID_INTEL,
181 				     PCI_DEVICE_ID_INTEL_82371AB,
182 				     PCI_ANY_ID, PCI_ANY_ID, NULL);
183 		if (dev) {
184 			errata.piix4.bmisx = pci_resource_start(dev, 4);
185 			pci_dev_put(dev);
186 		}
187 
188 		/*
189 		 * Type-F DMA
190 		 * ----------
191 		 * Find the PIIX4 ISA Controller and read the Motherboard
192 		 * DMA controller's status to see if Type-F (Fast) DMA mode
193 		 * is enabled (bit 7) on either channel.  Note that we'll
194 		 * disable C3 support if this is enabled, as some legacy
195 		 * devices won't operate well if fast DMA is disabled.
196 		 */
197 		dev = pci_get_subsys(PCI_VENDOR_ID_INTEL,
198 				     PCI_DEVICE_ID_INTEL_82371AB_0,
199 				     PCI_ANY_ID, PCI_ANY_ID, NULL);
200 		if (dev) {
201 			pci_read_config_byte(dev, 0x76, &value1);
202 			pci_read_config_byte(dev, 0x77, &value2);
203 			if ((value1 & 0x80) || (value2 & 0x80))
204 				errata.piix4.fdma = 1;
205 			pci_dev_put(dev);
206 		}
207 
208 		break;
209 	}
210 
211 	if (errata.piix4.bmisx)
212 		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
213 				  "Bus master activity detection (BM-IDE) erratum enabled\n"));
214 	if (errata.piix4.fdma)
215 		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
216 				  "Type-F DMA livelock erratum (C3 disabled)\n"));
217 
218 	return 0;
219 }
220 
221 static int acpi_processor_errata(struct acpi_processor *pr)
222 {
223 	int result = 0;
224 	struct pci_dev *dev = NULL;
225 
226 
227 	if (!pr)
228 		return -EINVAL;
229 
230 	/*
231 	 * PIIX4
232 	 */
233 	dev = pci_get_subsys(PCI_VENDOR_ID_INTEL,
234 			     PCI_DEVICE_ID_INTEL_82371AB_3, PCI_ANY_ID,
235 			     PCI_ANY_ID, NULL);
236 	if (dev) {
237 		result = acpi_processor_errata_piix4(dev);
238 		pci_dev_put(dev);
239 	}
240 
241 	return result;
242 }
243 
244 /* --------------------------------------------------------------------------
245                                  Driver Interface
246    -------------------------------------------------------------------------- */
247 
248 static int acpi_processor_get_info(struct acpi_device *device)
249 {
250 	acpi_status status = 0;
251 	union acpi_object object = { 0 };
252 	struct acpi_buffer buffer = { sizeof(union acpi_object), &object };
253 	struct acpi_processor *pr;
254 	int cpu_index, device_declaration = 0;
255 	static int cpu0_initialized;
256 
257 	pr = acpi_driver_data(device);
258 	if (!pr)
259 		return -EINVAL;
260 
261 	if (num_online_cpus() > 1)
262 		errata.smp = TRUE;
263 
264 	acpi_processor_errata(pr);
265 
266 	/*
267 	 * Check to see if we have bus mastering arbitration control.  This
268 	 * is required for proper C3 usage (to maintain cache coherency).
269 	 */
270 	if (acpi_gbl_FADT.pm2_control_block && acpi_gbl_FADT.pm2_control_length) {
271 		pr->flags.bm_control = 1;
272 		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
273 				  "Bus mastering arbitration control present\n"));
274 	} else
275 		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
276 				  "No bus mastering arbitration control\n"));
277 
278 	if (!strcmp(acpi_device_hid(device), ACPI_PROCESSOR_OBJECT_HID)) {
279 		/* Declared with "Processor" statement; match ProcessorID */
280 		status = acpi_evaluate_object(pr->handle, NULL, NULL, &buffer);
281 		if (ACPI_FAILURE(status)) {
282 			printk(KERN_ERR PREFIX "Evaluating processor object\n");
283 			return -ENODEV;
284 		}
285 
286 		/*
287 		 * TBD: Synch processor ID (via LAPIC/LSAPIC structures) on SMP.
288 		 *      >>> 'acpi_get_processor_id(acpi_id, &id)' in
289 		 *      arch/xxx/acpi.c
290 		 */
291 		pr->acpi_id = object.processor.proc_id;
292 	} else {
293 		/*
294 		 * Declared with "Device" statement; match _UID.
295 		 * Note that we don't handle string _UIDs yet.
296 		 */
297 		unsigned long long value;
298 		status = acpi_evaluate_integer(pr->handle, METHOD_NAME__UID,
299 						NULL, &value);
300 		if (ACPI_FAILURE(status)) {
301 			printk(KERN_ERR PREFIX
302 			    "Evaluating processor _UID [%#x]\n", status);
303 			return -ENODEV;
304 		}
305 		device_declaration = 1;
306 		pr->acpi_id = value;
307 	}
308 	cpu_index = acpi_get_cpuid(pr->handle, device_declaration, pr->acpi_id);
309 
310 	/* Handle UP system running SMP kernel, with no LAPIC in MADT */
311 	if (!cpu0_initialized && (cpu_index == -1) &&
312 	    (num_online_cpus() == 1)) {
313 		cpu_index = 0;
314 	}
315 
316 	cpu0_initialized = 1;
317 
318 	pr->id = cpu_index;
319 
320 	/*
321 	 *  Extra Processor objects may be enumerated on MP systems with
322 	 *  less than the max # of CPUs. They should be ignored _iff
323 	 *  they are physically not present.
324 	 */
325 	if (pr->id == -1) {
326 		if (ACPI_FAILURE(acpi_processor_hotadd_init(pr)))
327 			return -ENODEV;
328 	}
329 	/*
330 	 * On some boxes several processors use the same processor bus id.
331 	 * But they are located in different scope. For example:
332 	 * \_SB.SCK0.CPU0
333 	 * \_SB.SCK1.CPU0
334 	 * Rename the processor device bus id. And the new bus id will be
335 	 * generated as the following format:
336 	 * CPU+CPU ID.
337 	 */
338 	sprintf(acpi_device_bid(device), "CPU%X", pr->id);
339 	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Processor [%d:%d]\n", pr->id,
340 			  pr->acpi_id));
341 
342 	if (!object.processor.pblk_address)
343 		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No PBLK (NULL address)\n"));
344 	else if (object.processor.pblk_length != 6)
345 		printk(KERN_ERR PREFIX "Invalid PBLK length [%d]\n",
346 			    object.processor.pblk_length);
347 	else {
348 		pr->throttling.address = object.processor.pblk_address;
349 		pr->throttling.duty_offset = acpi_gbl_FADT.duty_offset;
350 		pr->throttling.duty_width = acpi_gbl_FADT.duty_width;
351 
352 		pr->pblk = object.processor.pblk_address;
353 
354 		/*
355 		 * We don't care about error returns - we just try to mark
356 		 * these reserved so that nobody else is confused into thinking
357 		 * that this region might be unused..
358 		 *
359 		 * (In particular, allocating the IO range for Cardbus)
360 		 */
361 		request_region(pr->throttling.address, 6, "ACPI CPU throttle");
362 	}
363 
364 	/*
365 	 * If ACPI describes a slot number for this CPU, we can use it
366 	 * ensure we get the right value in the "physical id" field
367 	 * of /proc/cpuinfo
368 	 */
369 	status = acpi_evaluate_object(pr->handle, "_SUN", NULL, &buffer);
370 	if (ACPI_SUCCESS(status))
371 		arch_fix_phys_package_id(pr->id, object.integer.value);
372 
373 	return 0;
374 }
375 
376 static DEFINE_PER_CPU(void *, processor_device_array);
377 
378 static void acpi_processor_notify(struct acpi_device *device, u32 event)
379 {
380 	struct acpi_processor *pr = acpi_driver_data(device);
381 	int saved;
382 
383 	if (!pr)
384 		return;
385 
386 	switch (event) {
387 	case ACPI_PROCESSOR_NOTIFY_PERFORMANCE:
388 		saved = pr->performance_platform_limit;
389 		acpi_processor_ppc_has_changed(pr, 1);
390 		if (saved == pr->performance_platform_limit)
391 			break;
392 		acpi_bus_generate_proc_event(device, event,
393 					pr->performance_platform_limit);
394 		acpi_bus_generate_netlink_event(device->pnp.device_class,
395 						  dev_name(&device->dev), event,
396 						  pr->performance_platform_limit);
397 		break;
398 	case ACPI_PROCESSOR_NOTIFY_POWER:
399 		acpi_processor_cst_has_changed(pr);
400 		acpi_bus_generate_proc_event(device, event, 0);
401 		acpi_bus_generate_netlink_event(device->pnp.device_class,
402 						  dev_name(&device->dev), event, 0);
403 		break;
404 	case ACPI_PROCESSOR_NOTIFY_THROTTLING:
405 		acpi_processor_tstate_has_changed(pr);
406 		acpi_bus_generate_proc_event(device, event, 0);
407 		acpi_bus_generate_netlink_event(device->pnp.device_class,
408 						  dev_name(&device->dev), event, 0);
409 	default:
410 		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
411 				  "Unsupported event [0x%x]\n", event));
412 		break;
413 	}
414 
415 	return;
416 }
417 
418 static int acpi_cpu_soft_notify(struct notifier_block *nfb,
419 		unsigned long action, void *hcpu)
420 {
421 	unsigned int cpu = (unsigned long)hcpu;
422 	struct acpi_processor *pr = per_cpu(processors, cpu);
423 
424 	if (action == CPU_ONLINE && pr) {
425 		/* CPU got physically hotplugged and onlined the first time:
426 		 * Initialize missing things
427 		 */
428 		if (pr->flags.need_hotplug_init) {
429 			struct cpuidle_driver *idle_driver =
430 				cpuidle_get_driver();
431 
432 			printk(KERN_INFO "Will online and init hotplugged "
433 			       "CPU: %d\n", pr->id);
434 			WARN(acpi_processor_start(pr), "Failed to start CPU:"
435 				" %d\n", pr->id);
436 			pr->flags.need_hotplug_init = 0;
437 			if (idle_driver && !strcmp(idle_driver->name,
438 						   "intel_idle")) {
439 				intel_idle_cpu_init(pr->id);
440 			}
441 		/* Normal CPU soft online event */
442 		} else {
443 			acpi_processor_ppc_has_changed(pr, 0);
444 			acpi_processor_cst_has_changed(pr);
445 			acpi_processor_reevaluate_tstate(pr, action);
446 			acpi_processor_tstate_has_changed(pr);
447 		}
448 	}
449 	if (action == CPU_DEAD && pr) {
450 		/* invalidate the flag.throttling after one CPU is offline */
451 		acpi_processor_reevaluate_tstate(pr, action);
452 	}
453 	return NOTIFY_OK;
454 }
455 
456 static struct notifier_block acpi_cpu_notifier =
457 {
458 	    .notifier_call = acpi_cpu_soft_notify,
459 };
460 
461 /*
462  * acpi_processor_start() is called by the cpu_hotplug_notifier func:
463  * acpi_cpu_soft_notify(). Getting it __cpuinit{data} is difficult, the
464  * root cause seem to be that acpi_processor_uninstall_hotplug_notify()
465  * is in the module_exit (__exit) func. Allowing acpi_processor_start()
466  * to not be in __cpuinit section, but being called from __cpuinit funcs
467  * via __ref looks like the right thing to do here.
468  */
469 static __ref int acpi_processor_start(struct acpi_processor *pr)
470 {
471 	struct acpi_device *device = per_cpu(processor_device_array, pr->id);
472 	int result = 0;
473 
474 #ifdef CONFIG_CPU_FREQ
475 	acpi_processor_ppc_has_changed(pr, 0);
476 	acpi_processor_load_module(pr);
477 #endif
478 	acpi_processor_get_throttling_info(pr);
479 	acpi_processor_get_limit_info(pr);
480 
481 	if (!cpuidle_get_driver() || cpuidle_get_driver() == &acpi_idle_driver)
482 		acpi_processor_power_init(pr, device);
483 
484 	pr->cdev = thermal_cooling_device_register("Processor", device,
485 						   &processor_cooling_ops);
486 	if (IS_ERR(pr->cdev)) {
487 		result = PTR_ERR(pr->cdev);
488 		goto err_power_exit;
489 	}
490 
491 	dev_dbg(&device->dev, "registered as cooling_device%d\n",
492 		pr->cdev->id);
493 
494 	result = sysfs_create_link(&device->dev.kobj,
495 				   &pr->cdev->device.kobj,
496 				   "thermal_cooling");
497 	if (result) {
498 		printk(KERN_ERR PREFIX "Create sysfs link\n");
499 		goto err_thermal_unregister;
500 	}
501 	result = sysfs_create_link(&pr->cdev->device.kobj,
502 				   &device->dev.kobj,
503 				   "device");
504 	if (result) {
505 		printk(KERN_ERR PREFIX "Create sysfs link\n");
506 		goto err_remove_sysfs_thermal;
507 	}
508 
509 	return 0;
510 
511 err_remove_sysfs_thermal:
512 	sysfs_remove_link(&device->dev.kobj, "thermal_cooling");
513 err_thermal_unregister:
514 	thermal_cooling_device_unregister(pr->cdev);
515 err_power_exit:
516 	acpi_processor_power_exit(pr, device);
517 
518 	return result;
519 }
520 
521 /*
522  * Do not put anything in here which needs the core to be online.
523  * For example MSR access or setting up things which check for cpuinfo_x86
524  * (cpu_data(cpu)) values, like CPU feature flags, family, model, etc.
525  * Such things have to be put in and set up above in acpi_processor_start()
526  */
527 static int __cpuinit acpi_processor_add(struct acpi_device *device)
528 {
529 	struct acpi_processor *pr = NULL;
530 	int result = 0;
531 	struct device *dev;
532 
533 	pr = kzalloc(sizeof(struct acpi_processor), GFP_KERNEL);
534 	if (!pr)
535 		return -ENOMEM;
536 
537 	if (!zalloc_cpumask_var(&pr->throttling.shared_cpu_map, GFP_KERNEL)) {
538 		kfree(pr);
539 		return -ENOMEM;
540 	}
541 
542 	pr->handle = device->handle;
543 	strcpy(acpi_device_name(device), ACPI_PROCESSOR_DEVICE_NAME);
544 	strcpy(acpi_device_class(device), ACPI_PROCESSOR_CLASS);
545 	device->driver_data = pr;
546 
547 	result = acpi_processor_get_info(device);
548 	if (result) {
549 		/* Processor is physically not present */
550 		return 0;
551 	}
552 
553 #ifdef CONFIG_SMP
554 	if (pr->id >= setup_max_cpus && pr->id != 0)
555 		return 0;
556 #endif
557 
558 	BUG_ON((pr->id >= nr_cpu_ids) || (pr->id < 0));
559 
560 	/*
561 	 * Buggy BIOS check
562 	 * ACPI id of processors can be reported wrongly by the BIOS.
563 	 * Don't trust it blindly
564 	 */
565 	if (per_cpu(processor_device_array, pr->id) != NULL &&
566 	    per_cpu(processor_device_array, pr->id) != device) {
567 		printk(KERN_WARNING "BIOS reported wrong ACPI id "
568 			"for the processor\n");
569 		result = -ENODEV;
570 		goto err_free_cpumask;
571 	}
572 	per_cpu(processor_device_array, pr->id) = device;
573 
574 	per_cpu(processors, pr->id) = pr;
575 
576 	dev = get_cpu_device(pr->id);
577 	if (sysfs_create_link(&device->dev.kobj, &dev->kobj, "sysdev")) {
578 		result = -EFAULT;
579 		goto err_free_cpumask;
580 	}
581 
582 	/*
583 	 * Do not start hotplugged CPUs now, but when they
584 	 * are onlined the first time
585 	 */
586 	if (pr->flags.need_hotplug_init)
587 		return 0;
588 
589 	result = acpi_processor_start(pr);
590 	if (result)
591 		goto err_remove_sysfs;
592 
593 	return 0;
594 
595 err_remove_sysfs:
596 	sysfs_remove_link(&device->dev.kobj, "sysdev");
597 err_free_cpumask:
598 	free_cpumask_var(pr->throttling.shared_cpu_map);
599 
600 	return result;
601 }
602 
603 static int acpi_processor_remove(struct acpi_device *device, int type)
604 {
605 	struct acpi_processor *pr = NULL;
606 
607 
608 	if (!device || !acpi_driver_data(device))
609 		return -EINVAL;
610 
611 	pr = acpi_driver_data(device);
612 
613 	if (pr->id >= nr_cpu_ids)
614 		goto free;
615 
616 	if (type == ACPI_BUS_REMOVAL_EJECT) {
617 		if (acpi_processor_handle_eject(pr))
618 			return -EINVAL;
619 	}
620 
621 	acpi_processor_power_exit(pr, device);
622 
623 	sysfs_remove_link(&device->dev.kobj, "sysdev");
624 
625 	if (pr->cdev) {
626 		sysfs_remove_link(&device->dev.kobj, "thermal_cooling");
627 		sysfs_remove_link(&pr->cdev->device.kobj, "device");
628 		thermal_cooling_device_unregister(pr->cdev);
629 		pr->cdev = NULL;
630 	}
631 
632 	per_cpu(processors, pr->id) = NULL;
633 	per_cpu(processor_device_array, pr->id) = NULL;
634 
635 free:
636 	free_cpumask_var(pr->throttling.shared_cpu_map);
637 	kfree(pr);
638 
639 	return 0;
640 }
641 
642 #ifdef CONFIG_ACPI_HOTPLUG_CPU
643 /****************************************************************************
644  * 	Acpi processor hotplug support 				       	    *
645  ****************************************************************************/
646 
647 static int is_processor_present(acpi_handle handle)
648 {
649 	acpi_status status;
650 	unsigned long long sta = 0;
651 
652 
653 	status = acpi_evaluate_integer(handle, "_STA", NULL, &sta);
654 
655 	if (ACPI_SUCCESS(status) && (sta & ACPI_STA_DEVICE_PRESENT))
656 		return 1;
657 
658 	/*
659 	 * _STA is mandatory for a processor that supports hot plug
660 	 */
661 	if (status == AE_NOT_FOUND)
662 		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
663 				"Processor does not support hot plug\n"));
664 	else
665 		ACPI_EXCEPTION((AE_INFO, status,
666 				"Processor Device is not present"));
667 	return 0;
668 }
669 
670 static
671 int acpi_processor_device_add(acpi_handle handle, struct acpi_device **device)
672 {
673 	acpi_handle phandle;
674 	struct acpi_device *pdev;
675 
676 
677 	if (acpi_get_parent(handle, &phandle)) {
678 		return -ENODEV;
679 	}
680 
681 	if (acpi_bus_get_device(phandle, &pdev)) {
682 		return -ENODEV;
683 	}
684 
685 	if (acpi_bus_add(device, pdev, handle, ACPI_BUS_TYPE_PROCESSOR)) {
686 		return -ENODEV;
687 	}
688 
689 	return 0;
690 }
691 
692 static void acpi_processor_hotplug_notify(acpi_handle handle,
693 					  u32 event, void *data)
694 {
695 	struct acpi_processor *pr;
696 	struct acpi_device *device = NULL;
697 	int result;
698 
699 
700 	switch (event) {
701 	case ACPI_NOTIFY_BUS_CHECK:
702 	case ACPI_NOTIFY_DEVICE_CHECK:
703 		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
704 		"Processor driver received %s event\n",
705 		       (event == ACPI_NOTIFY_BUS_CHECK) ?
706 		       "ACPI_NOTIFY_BUS_CHECK" : "ACPI_NOTIFY_DEVICE_CHECK"));
707 
708 		if (!is_processor_present(handle))
709 			break;
710 
711 		if (acpi_bus_get_device(handle, &device)) {
712 			result = acpi_processor_device_add(handle, &device);
713 			if (result)
714 				printk(KERN_ERR PREFIX
715 					    "Unable to add the device\n");
716 			break;
717 		}
718 		break;
719 	case ACPI_NOTIFY_EJECT_REQUEST:
720 		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
721 				  "received ACPI_NOTIFY_EJECT_REQUEST\n"));
722 
723 		if (acpi_bus_get_device(handle, &device)) {
724 			printk(KERN_ERR PREFIX
725 				    "Device don't exist, dropping EJECT\n");
726 			break;
727 		}
728 		pr = acpi_driver_data(device);
729 		if (!pr) {
730 			printk(KERN_ERR PREFIX
731 				    "Driver data is NULL, dropping EJECT\n");
732 			return;
733 		}
734 		break;
735 	default:
736 		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
737 				  "Unsupported event [0x%x]\n", event));
738 		break;
739 	}
740 
741 	return;
742 }
743 
744 static acpi_status
745 processor_walk_namespace_cb(acpi_handle handle,
746 			    u32 lvl, void *context, void **rv)
747 {
748 	acpi_status status;
749 	int *action = context;
750 	acpi_object_type type = 0;
751 
752 	status = acpi_get_type(handle, &type);
753 	if (ACPI_FAILURE(status))
754 		return (AE_OK);
755 
756 	if (type != ACPI_TYPE_PROCESSOR)
757 		return (AE_OK);
758 
759 	switch (*action) {
760 	case INSTALL_NOTIFY_HANDLER:
761 		acpi_install_notify_handler(handle,
762 					    ACPI_SYSTEM_NOTIFY,
763 					    acpi_processor_hotplug_notify,
764 					    NULL);
765 		break;
766 	case UNINSTALL_NOTIFY_HANDLER:
767 		acpi_remove_notify_handler(handle,
768 					   ACPI_SYSTEM_NOTIFY,
769 					   acpi_processor_hotplug_notify);
770 		break;
771 	default:
772 		break;
773 	}
774 
775 	return (AE_OK);
776 }
777 
778 static acpi_status acpi_processor_hotadd_init(struct acpi_processor *pr)
779 {
780 	acpi_handle handle = pr->handle;
781 
782 	if (!is_processor_present(handle)) {
783 		return AE_ERROR;
784 	}
785 
786 	if (acpi_map_lsapic(handle, &pr->id))
787 		return AE_ERROR;
788 
789 	if (arch_register_cpu(pr->id)) {
790 		acpi_unmap_lsapic(pr->id);
791 		return AE_ERROR;
792 	}
793 
794 	/* CPU got hot-plugged, but cpu_data is not initialized yet
795 	 * Set flag to delay cpu_idle/throttling initialization
796 	 * in:
797 	 * acpi_processor_add()
798 	 *   acpi_processor_get_info()
799 	 * and do it when the CPU gets online the first time
800 	 * TBD: Cleanup above functions and try to do this more elegant.
801 	 */
802 	printk(KERN_INFO "CPU %d got hotplugged\n", pr->id);
803 	pr->flags.need_hotplug_init = 1;
804 
805 	return AE_OK;
806 }
807 
808 static int acpi_processor_handle_eject(struct acpi_processor *pr)
809 {
810 	if (cpu_online(pr->id))
811 		cpu_down(pr->id);
812 
813 	arch_unregister_cpu(pr->id);
814 	acpi_unmap_lsapic(pr->id);
815 	return (0);
816 }
817 #else
818 static acpi_status acpi_processor_hotadd_init(struct acpi_processor *pr)
819 {
820 	return AE_ERROR;
821 }
822 static int acpi_processor_handle_eject(struct acpi_processor *pr)
823 {
824 	return (-EINVAL);
825 }
826 #endif
827 
828 static
829 void acpi_processor_install_hotplug_notify(void)
830 {
831 #ifdef CONFIG_ACPI_HOTPLUG_CPU
832 	int action = INSTALL_NOTIFY_HANDLER;
833 	acpi_walk_namespace(ACPI_TYPE_PROCESSOR,
834 			    ACPI_ROOT_OBJECT,
835 			    ACPI_UINT32_MAX,
836 			    processor_walk_namespace_cb, NULL, &action, NULL);
837 #endif
838 	register_hotcpu_notifier(&acpi_cpu_notifier);
839 }
840 
841 static
842 void acpi_processor_uninstall_hotplug_notify(void)
843 {
844 #ifdef CONFIG_ACPI_HOTPLUG_CPU
845 	int action = UNINSTALL_NOTIFY_HANDLER;
846 	acpi_walk_namespace(ACPI_TYPE_PROCESSOR,
847 			    ACPI_ROOT_OBJECT,
848 			    ACPI_UINT32_MAX,
849 			    processor_walk_namespace_cb, NULL, &action, NULL);
850 #endif
851 	unregister_hotcpu_notifier(&acpi_cpu_notifier);
852 }
853 
854 /*
855  * We keep the driver loaded even when ACPI is not running.
856  * This is needed for the powernow-k8 driver, that works even without
857  * ACPI, but needs symbols from this driver
858  */
859 
860 static int __init acpi_processor_init(void)
861 {
862 	int result = 0;
863 
864 	if (acpi_disabled)
865 		return 0;
866 
867 	memset(&errata, 0, sizeof(errata));
868 
869 	result = acpi_bus_register_driver(&acpi_processor_driver);
870 	if (result < 0)
871 		return result;
872 
873 	acpi_processor_install_hotplug_notify();
874 
875 	acpi_thermal_cpufreq_init();
876 
877 	acpi_processor_ppc_init();
878 
879 	acpi_processor_throttling_init();
880 
881 	return 0;
882 }
883 
884 static void __exit acpi_processor_exit(void)
885 {
886 	if (acpi_disabled)
887 		return;
888 
889 	acpi_processor_ppc_exit();
890 
891 	acpi_thermal_cpufreq_exit();
892 
893 	acpi_processor_uninstall_hotplug_notify();
894 
895 	acpi_bus_unregister_driver(&acpi_processor_driver);
896 
897 	return;
898 }
899 
900 module_init(acpi_processor_init);
901 module_exit(acpi_processor_exit);
902 
903 MODULE_ALIAS("processor");
904