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