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