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