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