processor_core.c revision 0b28002fdf2d5b6ce3135a544c04940a16c5b0ba 
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/proc_fs.h>
44#include <linux/seq_file.h>
45#include <linux/dmi.h>
46#include <linux/moduleparam.h>
47
48#include <asm/io.h>
49#include <asm/system.h>
50#include <asm/cpu.h>
51#include <asm/delay.h>
52#include <asm/uaccess.h>
53#include <asm/processor.h>
54#include <asm/smp.h>
55#include <asm/acpi.h>
56
57#include <acpi/acpi_bus.h>
58#include <acpi/acpi_drivers.h>
59#include <acpi/processor.h>
60
61#define ACPI_PROCESSOR_COMPONENT	0x01000000
62#define ACPI_PROCESSOR_CLASS		"processor"
63#define ACPI_PROCESSOR_DRIVER_NAME	"ACPI Processor Driver"
64#define ACPI_PROCESSOR_DEVICE_NAME	"Processor"
65#define ACPI_PROCESSOR_FILE_INFO	"info"
66#define ACPI_PROCESSOR_FILE_THROTTLING	"throttling"
67#define ACPI_PROCESSOR_FILE_LIMIT	"limit"
68#define ACPI_PROCESSOR_NOTIFY_PERFORMANCE 0x80
69#define ACPI_PROCESSOR_NOTIFY_POWER	0x81
70
71#define ACPI_PROCESSOR_LIMIT_USER	0
72#define ACPI_PROCESSOR_LIMIT_THERMAL	1
73
74#define ACPI_STA_PRESENT 0x00000001
75
76#define _COMPONENT		ACPI_PROCESSOR_COMPONENT
77ACPI_MODULE_NAME("acpi_processor")
78
79    MODULE_AUTHOR("Paul Diefenbaugh");
80MODULE_DESCRIPTION(ACPI_PROCESSOR_DRIVER_NAME);
81MODULE_LICENSE("GPL");
82
83static int acpi_processor_add(struct acpi_device *device);
84static int acpi_processor_start(struct acpi_device *device);
85static int acpi_processor_remove(struct acpi_device *device, int type);
86static int acpi_processor_info_open_fs(struct inode *inode, struct file *file);
87static void acpi_processor_notify(acpi_handle handle, u32 event, void *data);
88static acpi_status acpi_processor_hotadd_init(acpi_handle handle, int *p_cpu);
89static int acpi_processor_handle_eject(struct acpi_processor *pr);
90
91static struct acpi_driver acpi_processor_driver = {
92	.name = ACPI_PROCESSOR_DRIVER_NAME,
93	.class = ACPI_PROCESSOR_CLASS,
94	.ids = ACPI_PROCESSOR_HID,
95	.ops = {
96		.add = acpi_processor_add,
97		.remove = acpi_processor_remove,
98		.start = acpi_processor_start,
99		},
100};
101
102#define INSTALL_NOTIFY_HANDLER		1
103#define UNINSTALL_NOTIFY_HANDLER	2
104
105static struct file_operations acpi_processor_info_fops = {
106	.open = acpi_processor_info_open_fs,
107	.read = seq_read,
108	.llseek = seq_lseek,
109	.release = single_release,
110};
111
112struct acpi_processor *processors[NR_CPUS];
113struct acpi_processor_errata errata;
114
115/* --------------------------------------------------------------------------
116                                Errata Handling
117   -------------------------------------------------------------------------- */
118
119static int acpi_processor_errata_piix4(struct pci_dev *dev)
120{
121	u8 rev = 0;
122	u8 value1 = 0;
123	u8 value2 = 0;
124
125	ACPI_FUNCTION_TRACE("acpi_processor_errata_piix4");
126
127	if (!dev)
128		return_VALUE(-EINVAL);
129
130	/*
131	 * Note that 'dev' references the PIIX4 ACPI Controller.
132	 */
133
134	pci_read_config_byte(dev, PCI_REVISION_ID, &rev);
135
136	switch (rev) {
137	case 0:
138		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found PIIX4 A-step\n"));
139		break;
140	case 1:
141		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found PIIX4 B-step\n"));
142		break;
143	case 2:
144		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found PIIX4E\n"));
145		break;
146	case 3:
147		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found PIIX4M\n"));
148		break;
149	default:
150		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found unknown PIIX4\n"));
151		break;
152	}
153
154	switch (rev) {
155
156	case 0:		/* PIIX4 A-step */
157	case 1:		/* PIIX4 B-step */
158		/*
159		 * See specification changes #13 ("Manual Throttle Duty Cycle")
160		 * and #14 ("Enabling and Disabling Manual Throttle"), plus
161		 * erratum #5 ("STPCLK# Deassertion Time") from the January
162		 * 2002 PIIX4 specification update.  Applies to only older
163		 * PIIX4 models.
164		 */
165		errata.piix4.throttle = 1;
166
167	case 2:		/* PIIX4E */
168	case 3:		/* PIIX4M */
169		/*
170		 * See erratum #18 ("C3 Power State/BMIDE and Type-F DMA
171		 * Livelock") from the January 2002 PIIX4 specification update.
172		 * Applies to all PIIX4 models.
173		 */
174
175		/*
176		 * BM-IDE
177		 * ------
178		 * Find the PIIX4 IDE Controller and get the Bus Master IDE
179		 * Status register address.  We'll use this later to read
180		 * each IDE controller's DMA status to make sure we catch all
181		 * DMA activity.
182		 */
183		dev = pci_get_subsys(PCI_VENDOR_ID_INTEL,
184				     PCI_DEVICE_ID_INTEL_82371AB,
185				     PCI_ANY_ID, PCI_ANY_ID, NULL);
186		if (dev) {
187			errata.piix4.bmisx = pci_resource_start(dev, 4);
188			pci_dev_put(dev);
189		}
190
191		/*
192		 * Type-F DMA
193		 * ----------
194		 * Find the PIIX4 ISA Controller and read the Motherboard
195		 * DMA controller's status to see if Type-F (Fast) DMA mode
196		 * is enabled (bit 7) on either channel.  Note that we'll
197		 * disable C3 support if this is enabled, as some legacy
198		 * devices won't operate well if fast DMA is disabled.
199		 */
200		dev = pci_get_subsys(PCI_VENDOR_ID_INTEL,
201				     PCI_DEVICE_ID_INTEL_82371AB_0,
202				     PCI_ANY_ID, PCI_ANY_ID, NULL);
203		if (dev) {
204			pci_read_config_byte(dev, 0x76, &value1);
205			pci_read_config_byte(dev, 0x77, &value2);
206			if ((value1 & 0x80) || (value2 & 0x80))
207				errata.piix4.fdma = 1;
208			pci_dev_put(dev);
209		}
210
211		break;
212	}
213
214	if (errata.piix4.bmisx)
215		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
216				  "Bus master activity detection (BM-IDE) erratum enabled\n"));
217	if (errata.piix4.fdma)
218		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
219				  "Type-F DMA livelock erratum (C3 disabled)\n"));
220
221	return_VALUE(0);
222}
223
224static int acpi_processor_errata(struct acpi_processor *pr)
225{
226	int result = 0;
227	struct pci_dev *dev = NULL;
228
229	ACPI_FUNCTION_TRACE("acpi_processor_errata");
230
231	if (!pr)
232		return_VALUE(-EINVAL);
233
234	/*
235	 * PIIX4
236	 */
237	dev = pci_get_subsys(PCI_VENDOR_ID_INTEL,
238			     PCI_DEVICE_ID_INTEL_82371AB_3, PCI_ANY_ID,
239			     PCI_ANY_ID, NULL);
240	if (dev) {
241		result = acpi_processor_errata_piix4(dev);
242		pci_dev_put(dev);
243	}
244
245	return_VALUE(result);
246}
247
248/* --------------------------------------------------------------------------
249                              Common ACPI processor functions
250   -------------------------------------------------------------------------- */
251
252/*
253 * _PDC is required for a BIOS-OS handshake for most of the newer
254 * ACPI processor features.
255 */
256static int acpi_processor_set_pdc(struct acpi_processor *pr)
257{
258	struct acpi_object_list *pdc_in = pr->pdc;
259	acpi_status status = AE_OK;
260
261	ACPI_FUNCTION_TRACE("acpi_processor_set_pdc");
262
263	if (!pdc_in)
264		return_VALUE(status);
265
266	status = acpi_evaluate_object(pr->handle, "_PDC", pdc_in, NULL);
267
268	if (ACPI_FAILURE(status))
269		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
270		    "Could not evaluate _PDC, using legacy perf. control...\n"));
271
272	return_VALUE(status);
273}
274
275/* --------------------------------------------------------------------------
276                              FS Interface (/proc)
277   -------------------------------------------------------------------------- */
278
279static struct proc_dir_entry *acpi_processor_dir = NULL;
280
281static int acpi_processor_info_seq_show(struct seq_file *seq, void *offset)
282{
283	struct acpi_processor *pr = (struct acpi_processor *)seq->private;
284
285	ACPI_FUNCTION_TRACE("acpi_processor_info_seq_show");
286
287	if (!pr)
288		goto end;
289
290	seq_printf(seq, "processor id:            %d\n"
291		   "acpi id:                 %d\n"
292		   "bus mastering control:   %s\n"
293		   "power management:        %s\n"
294		   "throttling control:      %s\n"
295		   "limit interface:         %s\n",
296		   pr->id,
297		   pr->acpi_id,
298		   pr->flags.bm_control ? "yes" : "no",
299		   pr->flags.power ? "yes" : "no",
300		   pr->flags.throttling ? "yes" : "no",
301		   pr->flags.limit ? "yes" : "no");
302
303      end:
304	return_VALUE(0);
305}
306
307static int acpi_processor_info_open_fs(struct inode *inode, struct file *file)
308{
309	return single_open(file, acpi_processor_info_seq_show,
310			   PDE(inode)->data);
311}
312
313static int acpi_processor_add_fs(struct acpi_device *device)
314{
315	struct proc_dir_entry *entry = NULL;
316
317	ACPI_FUNCTION_TRACE("acpi_processor_add_fs");
318
319	if (!acpi_device_dir(device)) {
320		acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device),
321						     acpi_processor_dir);
322		if (!acpi_device_dir(device))
323			return_VALUE(-ENODEV);
324	}
325	acpi_device_dir(device)->owner = THIS_MODULE;
326
327	/* 'info' [R] */
328	entry = create_proc_entry(ACPI_PROCESSOR_FILE_INFO,
329				  S_IRUGO, acpi_device_dir(device));
330	if (!entry)
331		ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
332				  "Unable to create '%s' fs entry\n",
333				  ACPI_PROCESSOR_FILE_INFO));
334	else {
335		entry->proc_fops = &acpi_processor_info_fops;
336		entry->data = acpi_driver_data(device);
337		entry->owner = THIS_MODULE;
338	}
339
340	/* 'throttling' [R/W] */
341	entry = create_proc_entry(ACPI_PROCESSOR_FILE_THROTTLING,
342				  S_IFREG | S_IRUGO | S_IWUSR,
343				  acpi_device_dir(device));
344	if (!entry)
345		ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
346				  "Unable to create '%s' fs entry\n",
347				  ACPI_PROCESSOR_FILE_THROTTLING));
348	else {
349		entry->proc_fops = &acpi_processor_throttling_fops;
350		entry->data = acpi_driver_data(device);
351		entry->owner = THIS_MODULE;
352	}
353
354	/* 'limit' [R/W] */
355	entry = create_proc_entry(ACPI_PROCESSOR_FILE_LIMIT,
356				  S_IFREG | S_IRUGO | S_IWUSR,
357				  acpi_device_dir(device));
358	if (!entry)
359		ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
360				  "Unable to create '%s' fs entry\n",
361				  ACPI_PROCESSOR_FILE_LIMIT));
362	else {
363		entry->proc_fops = &acpi_processor_limit_fops;
364		entry->data = acpi_driver_data(device);
365		entry->owner = THIS_MODULE;
366	}
367
368	return_VALUE(0);
369}
370
371static int acpi_processor_remove_fs(struct acpi_device *device)
372{
373	ACPI_FUNCTION_TRACE("acpi_processor_remove_fs");
374
375	if (acpi_device_dir(device)) {
376		remove_proc_entry(ACPI_PROCESSOR_FILE_INFO,
377				  acpi_device_dir(device));
378		remove_proc_entry(ACPI_PROCESSOR_FILE_THROTTLING,
379				  acpi_device_dir(device));
380		remove_proc_entry(ACPI_PROCESSOR_FILE_LIMIT,
381				  acpi_device_dir(device));
382		remove_proc_entry(acpi_device_bid(device), acpi_processor_dir);
383		acpi_device_dir(device) = NULL;
384	}
385
386	return_VALUE(0);
387}
388
389/* Use the acpiid in MADT to map cpus in case of SMP */
390#ifndef CONFIG_SMP
391#define convert_acpiid_to_cpu(acpi_id) (0xff)
392#else
393
394#ifdef CONFIG_IA64
395#define arch_acpiid_to_apicid 	ia64_acpiid_to_sapicid
396#define arch_cpu_to_apicid 	ia64_cpu_to_sapicid
397#define ARCH_BAD_APICID		(0xffff)
398#else
399#define arch_acpiid_to_apicid 	x86_acpiid_to_apicid
400#define arch_cpu_to_apicid 	x86_cpu_to_apicid
401#define ARCH_BAD_APICID		(0xff)
402#endif
403
404static u8 convert_acpiid_to_cpu(u8 acpi_id)
405{
406	u16 apic_id;
407	int i;
408
409	apic_id = arch_acpiid_to_apicid[acpi_id];
410	if (apic_id == ARCH_BAD_APICID)
411		return -1;
412
413	for (i = 0; i < NR_CPUS; i++) {
414		if (arch_cpu_to_apicid[i] == apic_id)
415			return i;
416	}
417	return -1;
418}
419#endif
420
421/* --------------------------------------------------------------------------
422                                 Driver Interface
423   -------------------------------------------------------------------------- */
424
425static int acpi_processor_get_info(struct acpi_processor *pr)
426{
427	acpi_status status = 0;
428	union acpi_object object = { 0 };
429	struct acpi_buffer buffer = { sizeof(union acpi_object), &object };
430	u8 cpu_index;
431	static int cpu0_initialized;
432
433	ACPI_FUNCTION_TRACE("acpi_processor_get_info");
434
435	if (!pr)
436		return_VALUE(-EINVAL);
437
438	if (num_online_cpus() > 1)
439		errata.smp = TRUE;
440
441	acpi_processor_errata(pr);
442
443	/*
444	 * Check to see if we have bus mastering arbitration control.  This
445	 * is required for proper C3 usage (to maintain cache coherency).
446	 */
447	if (acpi_fadt.V1_pm2_cnt_blk && acpi_fadt.pm2_cnt_len) {
448		pr->flags.bm_control = 1;
449		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
450				  "Bus mastering arbitration control present\n"));
451	} else
452		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
453				  "No bus mastering arbitration control\n"));
454
455	/*
456	 * Evalute the processor object.  Note that it is common on SMP to
457	 * have the first (boot) processor with a valid PBLK address while
458	 * all others have a NULL address.
459	 */
460	status = acpi_evaluate_object(pr->handle, NULL, NULL, &buffer);
461	if (ACPI_FAILURE(status)) {
462		ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
463				  "Error evaluating processor object\n"));
464		return_VALUE(-ENODEV);
465	}
466
467	/*
468	 * TBD: Synch processor ID (via LAPIC/LSAPIC structures) on SMP.
469	 *      >>> 'acpi_get_processor_id(acpi_id, &id)' in arch/xxx/acpi.c
470	 */
471	pr->acpi_id = object.processor.proc_id;
472
473	cpu_index = convert_acpiid_to_cpu(pr->acpi_id);
474
475	/* Handle UP system running SMP kernel, with no LAPIC in MADT */
476	if (!cpu0_initialized && (cpu_index == 0xff) &&
477	    (num_online_cpus() == 1)) {
478		cpu_index = 0;
479	}
480
481	cpu0_initialized = 1;
482
483	pr->id = cpu_index;
484
485	/*
486	 *  Extra Processor objects may be enumerated on MP systems with
487	 *  less than the max # of CPUs. They should be ignored _iff
488	 *  they are physically not present.
489	 */
490	if (cpu_index >= NR_CPUS) {
491		if (ACPI_FAILURE
492		    (acpi_processor_hotadd_init(pr->handle, &pr->id))) {
493			ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
494					  "Error getting cpuindex for acpiid 0x%x\n",
495					  pr->acpi_id));
496			return_VALUE(-ENODEV);
497		}
498	}
499
500	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Processor [%d:%d]\n", pr->id,
501			  pr->acpi_id));
502
503	if (!object.processor.pblk_address)
504		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No PBLK (NULL address)\n"));
505	else if (object.processor.pblk_length != 6)
506		ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid PBLK length [%d]\n",
507				  object.processor.pblk_length));
508	else {
509		pr->throttling.address = object.processor.pblk_address;
510		pr->throttling.duty_offset = acpi_fadt.duty_offset;
511		pr->throttling.duty_width = acpi_fadt.duty_width;
512
513		pr->pblk = object.processor.pblk_address;
514
515		/*
516		 * We don't care about error returns - we just try to mark
517		 * these reserved so that nobody else is confused into thinking
518		 * that this region might be unused..
519		 *
520		 * (In particular, allocating the IO range for Cardbus)
521		 */
522		request_region(pr->throttling.address, 6, "ACPI CPU throttle");
523	}
524
525#ifdef CONFIG_CPU_FREQ
526	acpi_processor_ppc_has_changed(pr);
527#endif
528	acpi_processor_get_throttling_info(pr);
529	acpi_processor_get_limit_info(pr);
530
531	return_VALUE(0);
532}
533
534static void *processor_device_array[NR_CPUS];
535
536static int acpi_processor_start(struct acpi_device *device)
537{
538	int result = 0;
539	acpi_status status = AE_OK;
540	struct acpi_processor *pr;
541
542	ACPI_FUNCTION_TRACE("acpi_processor_start");
543
544	pr = acpi_driver_data(device);
545
546	result = acpi_processor_get_info(pr);
547	if (result) {
548		/* Processor is physically not present */
549		return_VALUE(0);
550	}
551
552	BUG_ON((pr->id >= NR_CPUS) || (pr->id < 0));
553
554	/*
555	 * Buggy BIOS check
556	 * ACPI id of processors can be reported wrongly by the BIOS.
557	 * Don't trust it blindly
558	 */
559	if (processor_device_array[pr->id] != NULL &&
560	    processor_device_array[pr->id] != (void *)device) {
561		ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "BIOS reporting wrong ACPI id"
562			"for the processor\n"));
563		return_VALUE(-ENODEV);
564	}
565	processor_device_array[pr->id] = (void *)device;
566
567	processors[pr->id] = pr;
568
569	result = acpi_processor_add_fs(device);
570	if (result)
571		goto end;
572
573	status = acpi_install_notify_handler(pr->handle, ACPI_DEVICE_NOTIFY,
574					     acpi_processor_notify, pr);
575	if (ACPI_FAILURE(status)) {
576		ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
577				  "Error installing device notify handler\n"));
578	}
579
580	/* _PDC call should be done before doing anything else (if reqd.). */
581	arch_acpi_processor_init_pdc(pr);
582	acpi_processor_set_pdc(pr);
583
584	acpi_processor_power_init(pr, device);
585
586	if (pr->flags.throttling) {
587		printk(KERN_INFO PREFIX "%s [%s] (supports",
588		       acpi_device_name(device), acpi_device_bid(device));
589		printk(" %d throttling states", pr->throttling.state_count);
590		printk(")\n");
591	}
592
593      end:
594
595	return_VALUE(result);
596}
597
598static void acpi_processor_notify(acpi_handle handle, u32 event, void *data)
599{
600	struct acpi_processor *pr = (struct acpi_processor *)data;
601	struct acpi_device *device = NULL;
602
603	ACPI_FUNCTION_TRACE("acpi_processor_notify");
604
605	if (!pr)
606		return_VOID;
607
608	if (acpi_bus_get_device(pr->handle, &device))
609		return_VOID;
610
611	switch (event) {
612	case ACPI_PROCESSOR_NOTIFY_PERFORMANCE:
613		acpi_processor_ppc_has_changed(pr);
614		acpi_bus_generate_event(device, event,
615					pr->performance_platform_limit);
616		break;
617	case ACPI_PROCESSOR_NOTIFY_POWER:
618		acpi_processor_cst_has_changed(pr);
619		acpi_bus_generate_event(device, event, 0);
620		break;
621	default:
622		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
623				  "Unsupported event [0x%x]\n", event));
624		break;
625	}
626
627	return_VOID;
628}
629
630static int acpi_processor_add(struct acpi_device *device)
631{
632	struct acpi_processor *pr = NULL;
633
634	ACPI_FUNCTION_TRACE("acpi_processor_add");
635
636	if (!device)
637		return_VALUE(-EINVAL);
638
639	pr = kmalloc(sizeof(struct acpi_processor), GFP_KERNEL);
640	if (!pr)
641		return_VALUE(-ENOMEM);
642	memset(pr, 0, sizeof(struct acpi_processor));
643
644	pr->handle = device->handle;
645	strcpy(acpi_device_name(device), ACPI_PROCESSOR_DEVICE_NAME);
646	strcpy(acpi_device_class(device), ACPI_PROCESSOR_CLASS);
647	acpi_driver_data(device) = pr;
648
649	return_VALUE(0);
650}
651
652static int acpi_processor_remove(struct acpi_device *device, int type)
653{
654	acpi_status status = AE_OK;
655	struct acpi_processor *pr = NULL;
656
657	ACPI_FUNCTION_TRACE("acpi_processor_remove");
658
659	if (!device || !acpi_driver_data(device))
660		return_VALUE(-EINVAL);
661
662	pr = (struct acpi_processor *)acpi_driver_data(device);
663
664	if (pr->id >= NR_CPUS) {
665		kfree(pr);
666		return_VALUE(0);
667	}
668
669	if (type == ACPI_BUS_REMOVAL_EJECT) {
670		if (acpi_processor_handle_eject(pr))
671			return_VALUE(-EINVAL);
672	}
673
674	acpi_processor_power_exit(pr, device);
675
676	status = acpi_remove_notify_handler(pr->handle, ACPI_DEVICE_NOTIFY,
677					    acpi_processor_notify);
678	if (ACPI_FAILURE(status)) {
679		ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
680				  "Error removing notify handler\n"));
681	}
682
683	acpi_processor_remove_fs(device);
684
685	processors[pr->id] = NULL;
686
687	kfree(pr);
688
689	return_VALUE(0);
690}
691
692#ifdef CONFIG_ACPI_HOTPLUG_CPU
693/****************************************************************************
694 * 	Acpi processor hotplug support 				       	    *
695 ****************************************************************************/
696
697static int is_processor_present(acpi_handle handle);
698
699static int is_processor_present(acpi_handle handle)
700{
701	acpi_status status;
702	unsigned long sta = 0;
703
704	ACPI_FUNCTION_TRACE("is_processor_present");
705
706	status = acpi_evaluate_integer(handle, "_STA", NULL, &sta);
707	if (ACPI_FAILURE(status) || !(sta & ACPI_STA_PRESENT)) {
708		ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
709				  "Processor Device is not present\n"));
710		return_VALUE(0);
711	}
712	return_VALUE(1);
713}
714
715static
716int acpi_processor_device_add(acpi_handle handle, struct acpi_device **device)
717{
718	acpi_handle phandle;
719	struct acpi_device *pdev;
720	struct acpi_processor *pr;
721
722	ACPI_FUNCTION_TRACE("acpi_processor_device_add");
723
724	if (acpi_get_parent(handle, &phandle)) {
725		return_VALUE(-ENODEV);
726	}
727
728	if (acpi_bus_get_device(phandle, &pdev)) {
729		return_VALUE(-ENODEV);
730	}
731
732	if (acpi_bus_add(device, pdev, handle, ACPI_BUS_TYPE_PROCESSOR)) {
733		return_VALUE(-ENODEV);
734	}
735
736	acpi_bus_start(*device);
737
738	pr = acpi_driver_data(*device);
739	if (!pr)
740		return_VALUE(-ENODEV);
741
742	if ((pr->id >= 0) && (pr->id < NR_CPUS)) {
743		kobject_uevent(&(*device)->kobj, KOBJ_ONLINE);
744	}
745	return_VALUE(0);
746}
747
748static void
749acpi_processor_hotplug_notify(acpi_handle handle, u32 event, void *data)
750{
751	struct acpi_processor *pr;
752	struct acpi_device *device = NULL;
753	int result;
754
755	ACPI_FUNCTION_TRACE("acpi_processor_hotplug_notify");
756
757	switch (event) {
758	case ACPI_NOTIFY_BUS_CHECK:
759	case ACPI_NOTIFY_DEVICE_CHECK:
760		printk("Processor driver received %s event\n",
761		       (event == ACPI_NOTIFY_BUS_CHECK) ?
762		       "ACPI_NOTIFY_BUS_CHECK" : "ACPI_NOTIFY_DEVICE_CHECK");
763
764		if (!is_processor_present(handle))
765			break;
766
767		if (acpi_bus_get_device(handle, &device)) {
768			result = acpi_processor_device_add(handle, &device);
769			if (result)
770				ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
771						  "Unable to add the device\n"));
772			break;
773		}
774
775		pr = acpi_driver_data(device);
776		if (!pr) {
777			ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
778					  "Driver data is NULL\n"));
779			break;
780		}
781
782		if (pr->id >= 0 && (pr->id < NR_CPUS)) {
783			kobject_uevent(&device->kobj, KOBJ_OFFLINE);
784			break;
785		}
786
787		result = acpi_processor_start(device);
788		if ((!result) && ((pr->id >= 0) && (pr->id < NR_CPUS))) {
789			kobject_uevent(&device->kobj, KOBJ_ONLINE);
790		} else {
791			ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
792					  "Device [%s] failed to start\n",
793					  acpi_device_bid(device)));
794		}
795		break;
796	case ACPI_NOTIFY_EJECT_REQUEST:
797		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
798				  "received ACPI_NOTIFY_EJECT_REQUEST\n"));
799
800		if (acpi_bus_get_device(handle, &device)) {
801			ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
802					  "Device don't exist, dropping EJECT\n"));
803			break;
804		}
805		pr = acpi_driver_data(device);
806		if (!pr) {
807			ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
808					  "Driver data is NULL, dropping EJECT\n"));
809			return_VOID;
810		}
811
812		if ((pr->id < NR_CPUS) && (cpu_present(pr->id)))
813			kobject_uevent(&device->kobj, KOBJ_OFFLINE);
814		break;
815	default:
816		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
817				  "Unsupported event [0x%x]\n", event));
818		break;
819	}
820
821	return_VOID;
822}
823
824static acpi_status
825processor_walk_namespace_cb(acpi_handle handle,
826			    u32 lvl, void *context, void **rv)
827{
828	acpi_status status;
829	int *action = context;
830	acpi_object_type type = 0;
831
832	status = acpi_get_type(handle, &type);
833	if (ACPI_FAILURE(status))
834		return (AE_OK);
835
836	if (type != ACPI_TYPE_PROCESSOR)
837		return (AE_OK);
838
839	switch (*action) {
840	case INSTALL_NOTIFY_HANDLER:
841		acpi_install_notify_handler(handle,
842					    ACPI_SYSTEM_NOTIFY,
843					    acpi_processor_hotplug_notify,
844					    NULL);
845		break;
846	case UNINSTALL_NOTIFY_HANDLER:
847		acpi_remove_notify_handler(handle,
848					   ACPI_SYSTEM_NOTIFY,
849					   acpi_processor_hotplug_notify);
850		break;
851	default:
852		break;
853	}
854
855	return (AE_OK);
856}
857
858static acpi_status acpi_processor_hotadd_init(acpi_handle handle, int *p_cpu)
859{
860	ACPI_FUNCTION_TRACE("acpi_processor_hotadd_init");
861
862	if (!is_processor_present(handle)) {
863		return_VALUE(AE_ERROR);
864	}
865
866	if (acpi_map_lsapic(handle, p_cpu))
867		return_VALUE(AE_ERROR);
868
869	if (arch_register_cpu(*p_cpu)) {
870		acpi_unmap_lsapic(*p_cpu);
871		return_VALUE(AE_ERROR);
872	}
873
874	return_VALUE(AE_OK);
875}
876
877static int acpi_processor_handle_eject(struct acpi_processor *pr)
878{
879	if (cpu_online(pr->id)) {
880		return (-EINVAL);
881	}
882	arch_unregister_cpu(pr->id);
883	acpi_unmap_lsapic(pr->id);
884	return (0);
885}
886#else
887static acpi_status acpi_processor_hotadd_init(acpi_handle handle, int *p_cpu)
888{
889	return AE_ERROR;
890}
891static int acpi_processor_handle_eject(struct acpi_processor *pr)
892{
893	return (-EINVAL);
894}
895#endif
896
897static
898void acpi_processor_install_hotplug_notify(void)
899{
900#ifdef CONFIG_ACPI_HOTPLUG_CPU
901	int action = INSTALL_NOTIFY_HANDLER;
902	acpi_walk_namespace(ACPI_TYPE_PROCESSOR,
903			    ACPI_ROOT_OBJECT,
904			    ACPI_UINT32_MAX,
905			    processor_walk_namespace_cb, &action, NULL);
906#endif
907}
908
909static
910void acpi_processor_uninstall_hotplug_notify(void)
911{
912#ifdef CONFIG_ACPI_HOTPLUG_CPU
913	int action = UNINSTALL_NOTIFY_HANDLER;
914	acpi_walk_namespace(ACPI_TYPE_PROCESSOR,
915			    ACPI_ROOT_OBJECT,
916			    ACPI_UINT32_MAX,
917			    processor_walk_namespace_cb, &action, NULL);
918#endif
919}
920
921/*
922 * We keep the driver loaded even when ACPI is not running.
923 * This is needed for the powernow-k8 driver, that works even without
924 * ACPI, but needs symbols from this driver
925 */
926
927static int __init acpi_processor_init(void)
928{
929	int result = 0;
930
931	ACPI_FUNCTION_TRACE("acpi_processor_init");
932
933	memset(&processors, 0, sizeof(processors));
934	memset(&errata, 0, sizeof(errata));
935
936	acpi_processor_dir = proc_mkdir(ACPI_PROCESSOR_CLASS, acpi_root_dir);
937	if (!acpi_processor_dir)
938		return_VALUE(0);
939	acpi_processor_dir->owner = THIS_MODULE;
940
941	result = acpi_bus_register_driver(&acpi_processor_driver);
942	if (result < 0) {
943		remove_proc_entry(ACPI_PROCESSOR_CLASS, acpi_root_dir);
944		return_VALUE(0);
945	}
946
947	acpi_processor_install_hotplug_notify();
948
949	acpi_thermal_cpufreq_init();
950
951	acpi_processor_ppc_init();
952
953	return_VALUE(0);
954}
955
956static void __exit acpi_processor_exit(void)
957{
958	ACPI_FUNCTION_TRACE("acpi_processor_exit");
959
960	acpi_processor_ppc_exit();
961
962	acpi_thermal_cpufreq_exit();
963
964	acpi_processor_uninstall_hotplug_notify();
965
966	acpi_bus_unregister_driver(&acpi_processor_driver);
967
968	remove_proc_entry(ACPI_PROCESSOR_CLASS, acpi_root_dir);
969
970	return_VOID;
971}
972
973module_init(acpi_processor_init);
974module_exit(acpi_processor_exit);
975
976EXPORT_SYMBOL(acpi_processor_set_thermal_limit);
977
978MODULE_ALIAS("processor");
979