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