[ACPI] re-enable platform-specific hotkey drivers by default
[linux-2.6] / drivers / acpi / bus.c
1 /*
2  *  acpi_bus.c - ACPI Bus Driver ($Revision: 80 $)
3  *
4  *  Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
5  *
6  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7  *
8  *  This program is free software; you can redistribute it and/or modify
9  *  it under the terms of the GNU General Public License as published by
10  *  the Free Software Foundation; either version 2 of the License, or (at
11  *  your option) any later version.
12  *
13  *  This program is distributed in the hope that it will be useful, but
14  *  WITHOUT ANY WARRANTY; without even the implied warranty of
15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  *  General Public License for more details.
17  *
18  *  You should have received a copy of the GNU General Public License along
19  *  with this program; if not, write to the Free Software Foundation, Inc.,
20  *  59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
21  *
22  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
23  */
24
25 #include <linux/module.h>
26 #include <linux/init.h>
27 #include <linux/ioport.h>
28 #include <linux/list.h>
29 #include <linux/sched.h>
30 #include <linux/pm.h>
31 #include <linux/device.h>
32 #include <linux/proc_fs.h>
33 #ifdef CONFIG_X86
34 #include <asm/mpspec.h>
35 #endif
36 #include <acpi/acpi_bus.h>
37 #include <acpi/acpi_drivers.h>
38
39
40 #define _COMPONENT              ACPI_BUS_COMPONENT
41 ACPI_MODULE_NAME                ("acpi_bus")
42
43 #ifdef  CONFIG_X86
44 extern void __init acpi_pic_sci_set_trigger(unsigned int irq, u16 trigger);
45 #endif
46
47 FADT_DESCRIPTOR                 acpi_fadt;
48 EXPORT_SYMBOL(acpi_fadt);
49
50 struct acpi_device              *acpi_root;
51 struct proc_dir_entry           *acpi_root_dir;
52 EXPORT_SYMBOL(acpi_root_dir);
53
54 #define STRUCT_TO_INT(s)        (*((int*)&s))
55
56 /* --------------------------------------------------------------------------
57                                 Device Management
58    -------------------------------------------------------------------------- */
59
60 int
61 acpi_bus_get_device (
62         acpi_handle             handle,
63         struct acpi_device      **device)
64 {
65         acpi_status             status = AE_OK;
66
67         ACPI_FUNCTION_TRACE("acpi_bus_get_device");
68
69         if (!device)
70                 return_VALUE(-EINVAL);
71
72         /* TBD: Support fixed-feature devices */
73
74         status = acpi_get_data(handle, acpi_bus_data_handler, (void**) device);
75         if (ACPI_FAILURE(status) || !*device) {
76                 ACPI_DEBUG_PRINT((ACPI_DB_WARN, "No context for object [%p]\n",
77                         handle));
78                 return_VALUE(-ENODEV);
79         }
80
81         return_VALUE(0);
82 }
83 EXPORT_SYMBOL(acpi_bus_get_device);
84
85 int
86 acpi_bus_get_status (
87         struct acpi_device      *device)
88 {
89         acpi_status             status = AE_OK;
90         unsigned long           sta = 0;
91         
92         ACPI_FUNCTION_TRACE("acpi_bus_get_status");
93
94         if (!device)
95                 return_VALUE(-EINVAL);
96
97         /*
98          * Evaluate _STA if present.
99          */
100         if (device->flags.dynamic_status) {
101                 status = acpi_evaluate_integer(device->handle, "_STA", NULL, &sta);
102                 if (ACPI_FAILURE(status))
103                         return_VALUE(-ENODEV);
104                 STRUCT_TO_INT(device->status) = (int) sta;
105         }
106
107         /*
108          * Otherwise we assume the status of our parent (unless we don't
109          * have one, in which case status is implied).
110          */
111         else if (device->parent)
112                 device->status = device->parent->status;
113         else
114                 STRUCT_TO_INT(device->status) = 0x0F;
115
116         if (device->status.functional && !device->status.present) {
117                 printk(KERN_WARNING PREFIX "Device [%s] status [%08x]: "
118                         "functional but not present; setting present\n",
119                         device->pnp.bus_id,
120                         (u32) STRUCT_TO_INT(device->status));
121                 device->status.present = 1;
122         }
123
124         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device [%s] status [%08x]\n", 
125                 device->pnp.bus_id, (u32) STRUCT_TO_INT(device->status)));
126
127         return_VALUE(0);
128 }
129 EXPORT_SYMBOL(acpi_bus_get_status);
130
131
132 /* --------------------------------------------------------------------------
133                                  Power Management
134    -------------------------------------------------------------------------- */
135
136 int
137 acpi_bus_get_power (
138         acpi_handle             handle,
139         int                     *state)
140 {
141         int                     result = 0;
142         acpi_status             status = 0;
143         struct acpi_device      *device = NULL;
144         unsigned long           psc = 0;
145
146         ACPI_FUNCTION_TRACE("acpi_bus_get_power");
147
148         result = acpi_bus_get_device(handle, &device);
149         if (result)
150                 return_VALUE(result);
151
152         *state = ACPI_STATE_UNKNOWN;
153
154         if (!device->flags.power_manageable) {
155                 /* TBD: Non-recursive algorithm for walking up hierarchy */
156                 if (device->parent)
157                         *state = device->parent->power.state;
158                 else
159                         *state = ACPI_STATE_D0;
160         }
161         else {
162                 /*
163                  * Get the device's power state either directly (via _PSC) or 
164                  * indirectly (via power resources).
165                  */
166                 if (device->power.flags.explicit_get) {
167                         status = acpi_evaluate_integer(device->handle, "_PSC", 
168                                 NULL, &psc);
169                         if (ACPI_FAILURE(status))
170                                 return_VALUE(-ENODEV);
171                         device->power.state = (int) psc;
172                 }
173                 else if (device->power.flags.power_resources) {
174                         result = acpi_power_get_inferred_state(device);
175                         if (result)
176                                 return_VALUE(result);
177                 }
178
179                 *state = device->power.state;
180         }
181
182         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device [%s] power state is D%d\n",
183                 device->pnp.bus_id, device->power.state));
184
185         return_VALUE(0);
186 }
187 EXPORT_SYMBOL(acpi_bus_get_power);
188
189
190 int
191 acpi_bus_set_power (
192         acpi_handle             handle,
193         int                     state)
194 {
195         int                     result = 0;
196         acpi_status             status = AE_OK;
197         struct acpi_device      *device = NULL;
198         char                    object_name[5] = {'_','P','S','0'+state,'\0'};
199
200         ACPI_FUNCTION_TRACE("acpi_bus_set_power");
201
202         result = acpi_bus_get_device(handle, &device);
203         if (result)
204                 return_VALUE(result);
205
206         if ((state < ACPI_STATE_D0) || (state > ACPI_STATE_D3))
207                 return_VALUE(-EINVAL);
208
209         /* Make sure this is a valid target state */
210
211         if (!device->flags.power_manageable) {
212                 ACPI_DEBUG_PRINT((ACPI_DB_WARN, "Device is not power manageable\n"));
213                 return_VALUE(-ENODEV);
214         }
215         /*
216          * Get device's current power state if it's unknown
217          * This means device power state isn't initialized or previous setting failed
218          */
219         if (device->power.state == ACPI_STATE_UNKNOWN)
220                 acpi_bus_get_power(device->handle, &device->power.state);
221         if (state == device->power.state) {
222                 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device is already at D%d\n", state));
223                 return_VALUE(0);
224         }
225         if (!device->power.states[state].flags.valid) {
226                 ACPI_DEBUG_PRINT((ACPI_DB_WARN, "Device does not support D%d\n", state));
227                 return_VALUE(-ENODEV);
228         }
229         if (device->parent && (state < device->parent->power.state)) {
230                 ACPI_DEBUG_PRINT((ACPI_DB_WARN, "Cannot set device to a higher-powered state than parent\n"));
231                 return_VALUE(-ENODEV);
232         }
233
234         /*
235          * Transition Power
236          * ----------------
237          * On transitions to a high-powered state we first apply power (via
238          * power resources) then evalute _PSx.  Conversly for transitions to
239          * a lower-powered state.
240          */
241         if (state < device->power.state) {
242                 if (device->power.flags.power_resources) {
243                         result = acpi_power_transition(device, state);
244                         if (result)
245                                 goto end;
246                 }
247                 if (device->power.states[state].flags.explicit_set) {
248                         status = acpi_evaluate_object(device->handle, 
249                                 object_name, NULL, NULL);
250                         if (ACPI_FAILURE(status)) {
251                                 result = -ENODEV;
252                                 goto end;
253                         }
254                 }
255         }
256         else {
257                 if (device->power.states[state].flags.explicit_set) {
258                         status = acpi_evaluate_object(device->handle, 
259                                 object_name, NULL, NULL);
260                         if (ACPI_FAILURE(status)) {
261                                 result = -ENODEV;
262                                 goto end;
263                         }
264                 }
265                 if (device->power.flags.power_resources) {
266                         result = acpi_power_transition(device, state);
267                         if (result)
268                                 goto end;
269                 }
270         }
271
272 end:
273         if (result)
274                 ACPI_DEBUG_PRINT((ACPI_DB_WARN, "Error transitioning device [%s] to D%d\n",
275                         device->pnp.bus_id, state));
276         else
277                 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device [%s] transitioned to D%d\n",
278                         device->pnp.bus_id, state));
279
280         return_VALUE(result);
281 }
282 EXPORT_SYMBOL(acpi_bus_set_power);
283
284
285
286 /* --------------------------------------------------------------------------
287                                 Event Management
288    -------------------------------------------------------------------------- */
289
290 static DEFINE_SPINLOCK(acpi_bus_event_lock);
291
292 LIST_HEAD(acpi_bus_event_list);
293 DECLARE_WAIT_QUEUE_HEAD(acpi_bus_event_queue);
294
295 extern int                      event_is_open;
296
297 int
298 acpi_bus_generate_event (
299         struct acpi_device      *device,
300         u8                      type,
301         int                     data)
302 {
303         struct acpi_bus_event   *event = NULL;
304         unsigned long           flags = 0;
305
306         ACPI_FUNCTION_TRACE("acpi_bus_generate_event");
307
308         if (!device)
309                 return_VALUE(-EINVAL);
310
311         /* drop event on the floor if no one's listening */
312         if (!event_is_open)
313                 return_VALUE(0);
314
315         event = kmalloc(sizeof(struct acpi_bus_event), GFP_ATOMIC);
316         if (!event)
317                 return_VALUE(-ENOMEM);
318
319         strcpy(event->device_class, device->pnp.device_class);
320         strcpy(event->bus_id, device->pnp.bus_id);
321         event->type = type;
322         event->data = data;
323
324         spin_lock_irqsave(&acpi_bus_event_lock, flags);
325         list_add_tail(&event->node, &acpi_bus_event_list);
326         spin_unlock_irqrestore(&acpi_bus_event_lock, flags);
327
328         wake_up_interruptible(&acpi_bus_event_queue);
329
330         return_VALUE(0);
331 }
332 EXPORT_SYMBOL(acpi_bus_generate_event);
333
334 int
335 acpi_bus_receive_event (
336         struct acpi_bus_event   *event)
337 {
338         unsigned long           flags = 0;
339         struct acpi_bus_event   *entry = NULL;
340
341         DECLARE_WAITQUEUE(wait, current);
342
343         ACPI_FUNCTION_TRACE("acpi_bus_receive_event");
344
345         if (!event)
346                 return_VALUE(-EINVAL);
347
348         if (list_empty(&acpi_bus_event_list)) {
349
350                 set_current_state(TASK_INTERRUPTIBLE);
351                 add_wait_queue(&acpi_bus_event_queue, &wait);
352
353                 if (list_empty(&acpi_bus_event_list))
354                         schedule();
355
356                 remove_wait_queue(&acpi_bus_event_queue, &wait);
357                 set_current_state(TASK_RUNNING);
358
359                 if (signal_pending(current))
360                         return_VALUE(-ERESTARTSYS);
361         }
362
363         spin_lock_irqsave(&acpi_bus_event_lock, flags);
364         entry = list_entry(acpi_bus_event_list.next, struct acpi_bus_event, node);
365         if (entry)
366                 list_del(&entry->node);
367         spin_unlock_irqrestore(&acpi_bus_event_lock, flags);
368
369         if (!entry)
370                 return_VALUE(-ENODEV);
371
372         memcpy(event, entry, sizeof(struct acpi_bus_event));
373
374         kfree(entry);
375
376         return_VALUE(0);
377 }
378 EXPORT_SYMBOL(acpi_bus_receive_event);
379
380
381 /* --------------------------------------------------------------------------
382                              Notification Handling
383    -------------------------------------------------------------------------- */
384
385 static int
386 acpi_bus_check_device (
387         struct acpi_device      *device,
388         int                     *status_changed)
389 {
390         acpi_status             status = 0;
391         struct acpi_device_status old_status;
392
393         ACPI_FUNCTION_TRACE("acpi_bus_check_device");
394
395         if (!device)
396                 return_VALUE(-EINVAL);
397
398         if (status_changed)
399                 *status_changed = 0;
400
401         old_status = device->status;
402
403         /*
404          * Make sure this device's parent is present before we go about
405          * messing with the device.
406          */
407         if (device->parent && !device->parent->status.present) {
408                 device->status = device->parent->status;
409                 if (STRUCT_TO_INT(old_status) != STRUCT_TO_INT(device->status)) {
410                         if (status_changed)
411                                 *status_changed = 1;
412                 }
413                 return_VALUE(0);
414         }
415
416         status = acpi_bus_get_status(device);
417         if (ACPI_FAILURE(status))
418                 return_VALUE(-ENODEV);
419
420         if (STRUCT_TO_INT(old_status) == STRUCT_TO_INT(device->status))
421                 return_VALUE(0);
422
423         if (status_changed)
424                 *status_changed = 1;
425         
426         /*
427          * Device Insertion/Removal
428          */
429         if ((device->status.present) && !(old_status.present)) {
430                 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device insertion detected\n"));
431                 /* TBD: Handle device insertion */
432         }
433         else if (!(device->status.present) && (old_status.present)) {
434                 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device removal detected\n"));
435                 /* TBD: Handle device removal */
436         }
437
438         return_VALUE(0);
439 }
440
441
442 static int
443 acpi_bus_check_scope (
444         struct acpi_device      *device)
445 {
446         int                     result = 0;
447         int                     status_changed = 0;
448
449         ACPI_FUNCTION_TRACE("acpi_bus_check_scope");
450
451         if (!device)
452                 return_VALUE(-EINVAL);
453
454         /* Status Change? */
455         result = acpi_bus_check_device(device, &status_changed);
456         if (result)
457                 return_VALUE(result);
458
459         if (!status_changed)
460                 return_VALUE(0);
461
462         /*
463          * TBD: Enumerate child devices within this device's scope and
464          *       run acpi_bus_check_device()'s on them.
465          */
466
467         return_VALUE(0);
468 }
469
470
471 /**
472  * acpi_bus_notify
473  * ---------------
474  * Callback for all 'system-level' device notifications (values 0x00-0x7F).
475  */
476 static void 
477 acpi_bus_notify (
478         acpi_handle             handle,
479         u32                     type,
480         void                    *data)
481 {
482         int                     result = 0;
483         struct acpi_device      *device = NULL;
484
485         ACPI_FUNCTION_TRACE("acpi_bus_notify");
486
487         if (acpi_bus_get_device(handle, &device))
488                 return_VOID;
489
490         switch (type) {
491
492         case ACPI_NOTIFY_BUS_CHECK:
493                 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Received BUS CHECK notification for device [%s]\n", 
494                         device->pnp.bus_id));
495                 result = acpi_bus_check_scope(device);
496                 /* 
497                  * TBD: We'll need to outsource certain events to non-ACPI
498                  *      drivers via the device manager (device.c).
499                  */
500                 break;
501
502         case ACPI_NOTIFY_DEVICE_CHECK:
503                 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Received DEVICE CHECK notification for device [%s]\n", 
504                         device->pnp.bus_id));
505                 result = acpi_bus_check_device(device, NULL);
506                 /* 
507                  * TBD: We'll need to outsource certain events to non-ACPI
508                  *      drivers via the device manager (device.c).
509                  */
510                 break;
511
512         case ACPI_NOTIFY_DEVICE_WAKE:
513                 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Received DEVICE WAKE notification for device [%s]\n", 
514                         device->pnp.bus_id));
515                 /* TBD */
516                 break;
517
518         case ACPI_NOTIFY_EJECT_REQUEST:
519                 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Received EJECT REQUEST notification for device [%s]\n", 
520                         device->pnp.bus_id));
521                 /* TBD */
522                 break;
523
524         case ACPI_NOTIFY_DEVICE_CHECK_LIGHT:
525                 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Received DEVICE CHECK LIGHT notification for device [%s]\n", 
526                         device->pnp.bus_id));
527                 /* TBD: Exactly what does 'light' mean? */
528                 break;
529
530         case ACPI_NOTIFY_FREQUENCY_MISMATCH:
531                 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Received FREQUENCY MISMATCH notification for device [%s]\n", 
532                         device->pnp.bus_id));
533                 /* TBD */
534                 break;
535
536         case ACPI_NOTIFY_BUS_MODE_MISMATCH:
537                 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Received BUS MODE MISMATCH notification for device [%s]\n", 
538                         device->pnp.bus_id));
539                 /* TBD */
540                 break;
541
542         case ACPI_NOTIFY_POWER_FAULT:
543                 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Received POWER FAULT notification for device [%s]\n", 
544                         device->pnp.bus_id));
545                 /* TBD */
546                 break;
547
548         default:
549                 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Received unknown/unsupported notification [%08x]\n", 
550                         type));
551                 break;
552         }
553
554         return_VOID;
555 }
556
557 /* --------------------------------------------------------------------------
558                              Initialization/Cleanup
559    -------------------------------------------------------------------------- */
560
561 static int __init
562 acpi_bus_init_irq (void)
563 {
564         acpi_status             status = AE_OK;
565         union acpi_object       arg = {ACPI_TYPE_INTEGER};
566         struct acpi_object_list arg_list = {1, &arg};
567         char                    *message = NULL;
568
569         ACPI_FUNCTION_TRACE("acpi_bus_init_irq");
570
571         /* 
572          * Let the system know what interrupt model we are using by
573          * evaluating the \_PIC object, if exists.
574          */
575
576         switch (acpi_irq_model) {
577         case ACPI_IRQ_MODEL_PIC:
578                 message = "PIC";
579                 break;
580         case ACPI_IRQ_MODEL_IOAPIC:
581                 message = "IOAPIC";
582                 break;
583         case ACPI_IRQ_MODEL_IOSAPIC:
584                 message = "IOSAPIC";
585                 break;
586         default:
587                 printk(KERN_WARNING PREFIX "Unknown interrupt routing model\n");
588                 return_VALUE(-ENODEV);
589         }
590
591         printk(KERN_INFO PREFIX "Using %s for interrupt routing\n", message);
592
593         arg.integer.value = acpi_irq_model;
594
595         status = acpi_evaluate_object(NULL, "\\_PIC", &arg_list, NULL);
596         if (ACPI_FAILURE(status) && (status != AE_NOT_FOUND)) {
597                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Error evaluating _PIC\n"));
598                 return_VALUE(-ENODEV);
599         }
600
601         return_VALUE(0);
602 }
603
604
605 void __init
606 acpi_early_init (void)
607 {
608         acpi_status             status = AE_OK;
609         struct acpi_buffer      buffer = {sizeof(acpi_fadt), &acpi_fadt};
610
611         ACPI_FUNCTION_TRACE("acpi_early_init");
612
613         if (acpi_disabled)
614                 return_VOID;
615
616         /* enable workarounds, unless strict ACPI spec. compliance */
617         if (!acpi_strict)
618                 acpi_gbl_enable_interpreter_slack = TRUE;
619
620         status = acpi_initialize_subsystem();
621         if (ACPI_FAILURE(status)) {
622                 printk(KERN_ERR PREFIX "Unable to initialize the ACPI Interpreter\n");
623                 goto error0;
624         }
625
626         status = acpi_load_tables();
627         if (ACPI_FAILURE(status)) {
628                 printk(KERN_ERR PREFIX "Unable to load the System Description Tables\n");
629                 goto error0;
630         }
631
632         /*
633          * Get a separate copy of the FADT for use by other drivers.
634          */
635         status = acpi_get_table(ACPI_TABLE_FADT, 1, &buffer);
636         if (ACPI_FAILURE(status)) {
637                 printk(KERN_ERR PREFIX "Unable to get the FADT\n");
638                 goto error0;
639         }
640
641 #ifdef CONFIG_X86
642         if (!acpi_ioapic) {
643                 extern acpi_interrupt_flags acpi_sci_flags;
644
645                 /* compatible (0) means level (3) */
646                 if (acpi_sci_flags.trigger == 0)
647                         acpi_sci_flags.trigger = 3;
648
649                 /* Set PIC-mode SCI trigger type */
650                 acpi_pic_sci_set_trigger(acpi_fadt.sci_int, acpi_sci_flags.trigger);
651         } else {
652                 extern int acpi_sci_override_gsi;
653                 /*
654                  * now that acpi_fadt is initialized,
655                  * update it with result from INT_SRC_OVR parsing
656                  */
657                 acpi_fadt.sci_int = acpi_sci_override_gsi;
658         }
659 #endif
660
661         status = acpi_enable_subsystem(~(ACPI_NO_HARDWARE_INIT | ACPI_NO_ACPI_ENABLE));
662         if (ACPI_FAILURE(status)) {
663                 printk(KERN_ERR PREFIX "Unable to enable ACPI\n");
664                 goto error0;
665         }
666
667         return_VOID;
668
669 error0:
670         disable_acpi();
671         return_VOID;
672 }
673
674 static int __init
675 acpi_bus_init (void)
676 {
677         int                     result = 0;
678         acpi_status             status = AE_OK;
679         extern acpi_status      acpi_os_initialize1(void);
680
681         ACPI_FUNCTION_TRACE("acpi_bus_init");
682
683         status = acpi_os_initialize1();
684
685         status = acpi_enable_subsystem(ACPI_NO_HARDWARE_INIT | ACPI_NO_ACPI_ENABLE);
686         if (ACPI_FAILURE(status)) {
687                 printk(KERN_ERR PREFIX "Unable to start the ACPI Interpreter\n");
688                 goto error1;
689         }
690
691         if (ACPI_FAILURE(status)) {
692                 printk(KERN_ERR PREFIX "Unable to initialize ACPI OS objects\n");
693                 goto error1;
694         }
695 #ifdef CONFIG_ACPI_EC
696         /*
697          * ACPI 2.0 requires the EC driver to be loaded and work before
698          * the EC device is found in the namespace (i.e. before acpi_initialize_objects()
699          * is called).
700          *
701          * This is accomplished by looking for the ECDT table, and getting 
702          * the EC parameters out of that.
703          */
704         status = acpi_ec_ecdt_probe();
705         /* Ignore result. Not having an ECDT is not fatal. */
706 #endif
707
708         status = acpi_initialize_objects(ACPI_FULL_INITIALIZATION);
709         if (ACPI_FAILURE(status)) {
710                 printk(KERN_ERR PREFIX "Unable to initialize ACPI objects\n");
711                 goto error1;
712         }
713
714         printk(KERN_INFO PREFIX "Interpreter enabled\n");
715
716         /*
717          * Get the system interrupt model and evaluate \_PIC.
718          */
719         result = acpi_bus_init_irq();
720         if (result)
721                 goto error1;
722
723         /*
724          * Register the for all standard device notifications.
725          */
726         status = acpi_install_notify_handler(ACPI_ROOT_OBJECT, ACPI_SYSTEM_NOTIFY, &acpi_bus_notify, NULL);
727         if (ACPI_FAILURE(status)) {
728                 printk(KERN_ERR PREFIX "Unable to register for device notifications\n");
729                 goto error1;
730         }
731
732         /*
733          * Create the top ACPI proc directory
734          */
735         acpi_root_dir = proc_mkdir(ACPI_BUS_FILE_ROOT, NULL);
736
737         return_VALUE(0);
738
739         /* Mimic structured exception handling */
740 error1:
741         acpi_terminate();
742         return_VALUE(-ENODEV);
743 }
744
745 decl_subsys(acpi,NULL,NULL);
746
747 static int __init acpi_init (void)
748 {
749         int                     result = 0;
750
751         ACPI_FUNCTION_TRACE("acpi_init");
752
753         printk(KERN_INFO PREFIX "Subsystem revision %08x\n",
754                 ACPI_CA_VERSION);
755
756         if (acpi_disabled) {
757                 printk(KERN_INFO PREFIX "Interpreter disabled.\n");
758                 return_VALUE(-ENODEV);
759         }
760
761         firmware_register(&acpi_subsys);
762
763         result = acpi_bus_init();
764
765         if (!result) {
766 #ifdef CONFIG_PM
767                 if (!PM_IS_ACTIVE())
768                         pm_active = 1;
769                 else {
770                         printk(KERN_INFO PREFIX "APM is already active, exiting\n");
771                         disable_acpi();
772                         result = -ENODEV;
773                 }
774 #endif
775         } else
776                 disable_acpi();
777
778         return_VALUE(result);
779 }
780
781 subsys_initcall(acpi_init);