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