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