bus.c revision 19c38de88a80913351fcacefdb461cc0b585fa87
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 42ACPI_MODULE_NAME("bus"); 43#ifdef CONFIG_X86 44extern void __init acpi_pic_sci_set_trigger(unsigned int irq, u16 trigger); 45#endif 46 47struct acpi_device *acpi_root; 48struct proc_dir_entry *acpi_root_dir; 49EXPORT_SYMBOL(acpi_root_dir); 50 51#define STRUCT_TO_INT(s) (*((int*)&s)) 52 53/* -------------------------------------------------------------------------- 54 Device Management 55 -------------------------------------------------------------------------- */ 56 57int 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 77EXPORT_SYMBOL(acpi_bus_get_device); 78 79int 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 124EXPORT_SYMBOL(acpi_bus_get_status); 125 126/* -------------------------------------------------------------------------- 127 Power Management 128 -------------------------------------------------------------------------- */ 129 130int 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 176EXPORT_SYMBOL(acpi_bus_get_power); 177 178int 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 kobject_name(&device->dev.kobj))); 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 device->power.state = state; 267 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 268 "Device [%s] transitioned to D%d\n", 269 device->pnp.bus_id, state)); 270 } 271 272 return result; 273} 274 275EXPORT_SYMBOL(acpi_bus_set_power); 276 277/* -------------------------------------------------------------------------- 278 Event Management 279 -------------------------------------------------------------------------- */ 280 281#ifdef CONFIG_ACPI_PROC_EVENT 282static DEFINE_SPINLOCK(acpi_bus_event_lock); 283 284LIST_HEAD(acpi_bus_event_list); 285DECLARE_WAIT_QUEUE_HEAD(acpi_bus_event_queue); 286 287extern int event_is_open; 288 289int acpi_bus_generate_proc_event(struct acpi_device *device, u8 type, int data) 290{ 291 struct acpi_bus_event *event = NULL; 292 unsigned long flags = 0; 293 294 295 if (!device) 296 return -EINVAL; 297 298 /* drop event on the floor if no one's listening */ 299 if (!event_is_open) 300 return 0; 301 302 event = kmalloc(sizeof(struct acpi_bus_event), GFP_ATOMIC); 303 if (!event) 304 return -ENOMEM; 305 306 strcpy(event->device_class, device->pnp.device_class); 307 strcpy(event->bus_id, device->pnp.bus_id); 308 event->type = type; 309 event->data = data; 310 311 spin_lock_irqsave(&acpi_bus_event_lock, flags); 312 list_add_tail(&event->node, &acpi_bus_event_list); 313 spin_unlock_irqrestore(&acpi_bus_event_lock, flags); 314 315 wake_up_interruptible(&acpi_bus_event_queue); 316 317 return 0; 318} 319 320EXPORT_SYMBOL(acpi_bus_generate_proc_event); 321 322int acpi_bus_receive_event(struct acpi_bus_event *event) 323{ 324 unsigned long flags = 0; 325 struct acpi_bus_event *entry = NULL; 326 327 DECLARE_WAITQUEUE(wait, current); 328 329 330 if (!event) 331 return -EINVAL; 332 333 if (list_empty(&acpi_bus_event_list)) { 334 335 set_current_state(TASK_INTERRUPTIBLE); 336 add_wait_queue(&acpi_bus_event_queue, &wait); 337 338 if (list_empty(&acpi_bus_event_list)) 339 schedule(); 340 341 remove_wait_queue(&acpi_bus_event_queue, &wait); 342 set_current_state(TASK_RUNNING); 343 344 if (signal_pending(current)) 345 return -ERESTARTSYS; 346 } 347 348 spin_lock_irqsave(&acpi_bus_event_lock, flags); 349 entry = 350 list_entry(acpi_bus_event_list.next, struct acpi_bus_event, node); 351 if (entry) 352 list_del(&entry->node); 353 spin_unlock_irqrestore(&acpi_bus_event_lock, flags); 354 355 if (!entry) 356 return -ENODEV; 357 358 memcpy(event, entry, sizeof(struct acpi_bus_event)); 359 360 kfree(entry); 361 362 return 0; 363} 364 365EXPORT_SYMBOL(acpi_bus_receive_event); 366#endif /* CONFIG_ACPI_PROC_EVENT */ 367 368/* -------------------------------------------------------------------------- 369 Notification Handling 370 -------------------------------------------------------------------------- */ 371 372static int 373acpi_bus_check_device(struct acpi_device *device, int *status_changed) 374{ 375 acpi_status status = 0; 376 struct acpi_device_status old_status; 377 378 379 if (!device) 380 return -EINVAL; 381 382 if (status_changed) 383 *status_changed = 0; 384 385 old_status = device->status; 386 387 /* 388 * Make sure this device's parent is present before we go about 389 * messing with the device. 390 */ 391 if (device->parent && !device->parent->status.present) { 392 device->status = device->parent->status; 393 if (STRUCT_TO_INT(old_status) != STRUCT_TO_INT(device->status)) { 394 if (status_changed) 395 *status_changed = 1; 396 } 397 return 0; 398 } 399 400 status = acpi_bus_get_status(device); 401 if (ACPI_FAILURE(status)) 402 return -ENODEV; 403 404 if (STRUCT_TO_INT(old_status) == STRUCT_TO_INT(device->status)) 405 return 0; 406 407 if (status_changed) 408 *status_changed = 1; 409 410 /* 411 * Device Insertion/Removal 412 */ 413 if ((device->status.present) && !(old_status.present)) { 414 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device insertion detected\n")); 415 /* TBD: Handle device insertion */ 416 } else if (!(device->status.present) && (old_status.present)) { 417 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device removal detected\n")); 418 /* TBD: Handle device removal */ 419 } 420 421 return 0; 422} 423 424static int acpi_bus_check_scope(struct acpi_device *device) 425{ 426 int result = 0; 427 int status_changed = 0; 428 429 430 if (!device) 431 return -EINVAL; 432 433 /* Status Change? */ 434 result = acpi_bus_check_device(device, &status_changed); 435 if (result) 436 return result; 437 438 if (!status_changed) 439 return 0; 440 441 /* 442 * TBD: Enumerate child devices within this device's scope and 443 * run acpi_bus_check_device()'s on them. 444 */ 445 446 return 0; 447} 448 449/** 450 * acpi_bus_notify 451 * --------------- 452 * Callback for all 'system-level' device notifications (values 0x00-0x7F). 453 */ 454static void acpi_bus_notify(acpi_handle handle, u32 type, void *data) 455{ 456 int result = 0; 457 struct acpi_device *device = NULL; 458 459 460 if (acpi_bus_get_device(handle, &device)) 461 return; 462 463 switch (type) { 464 465 case ACPI_NOTIFY_BUS_CHECK: 466 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 467 "Received BUS CHECK notification for device [%s]\n", 468 device->pnp.bus_id)); 469 result = acpi_bus_check_scope(device); 470 /* 471 * TBD: We'll need to outsource certain events to non-ACPI 472 * drivers via the device manager (device.c). 473 */ 474 break; 475 476 case ACPI_NOTIFY_DEVICE_CHECK: 477 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 478 "Received DEVICE CHECK notification for device [%s]\n", 479 device->pnp.bus_id)); 480 result = acpi_bus_check_device(device, NULL); 481 /* 482 * TBD: We'll need to outsource certain events to non-ACPI 483 * drivers via the device manager (device.c). 484 */ 485 break; 486 487 case ACPI_NOTIFY_DEVICE_WAKE: 488 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 489 "Received DEVICE WAKE notification for device [%s]\n", 490 device->pnp.bus_id)); 491 /* TBD */ 492 break; 493 494 case ACPI_NOTIFY_EJECT_REQUEST: 495 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 496 "Received EJECT REQUEST notification for device [%s]\n", 497 device->pnp.bus_id)); 498 /* TBD */ 499 break; 500 501 case ACPI_NOTIFY_DEVICE_CHECK_LIGHT: 502 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 503 "Received DEVICE CHECK LIGHT notification for device [%s]\n", 504 device->pnp.bus_id)); 505 /* TBD: Exactly what does 'light' mean? */ 506 break; 507 508 case ACPI_NOTIFY_FREQUENCY_MISMATCH: 509 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 510 "Received FREQUENCY MISMATCH notification for device [%s]\n", 511 device->pnp.bus_id)); 512 /* TBD */ 513 break; 514 515 case ACPI_NOTIFY_BUS_MODE_MISMATCH: 516 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 517 "Received BUS MODE MISMATCH notification for device [%s]\n", 518 device->pnp.bus_id)); 519 /* TBD */ 520 break; 521 522 case ACPI_NOTIFY_POWER_FAULT: 523 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 524 "Received POWER FAULT notification for device [%s]\n", 525 device->pnp.bus_id)); 526 /* TBD */ 527 break; 528 529 default: 530 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 531 "Received unknown/unsupported notification [%08x]\n", 532 type)); 533 break; 534 } 535 536 return; 537} 538 539/* -------------------------------------------------------------------------- 540 Initialization/Cleanup 541 -------------------------------------------------------------------------- */ 542 543static int __init acpi_bus_init_irq(void) 544{ 545 acpi_status status = AE_OK; 546 union acpi_object arg = { ACPI_TYPE_INTEGER }; 547 struct acpi_object_list arg_list = { 1, &arg }; 548 char *message = NULL; 549 550 551 /* 552 * Let the system know what interrupt model we are using by 553 * evaluating the \_PIC object, if exists. 554 */ 555 556 switch (acpi_irq_model) { 557 case ACPI_IRQ_MODEL_PIC: 558 message = "PIC"; 559 break; 560 case ACPI_IRQ_MODEL_IOAPIC: 561 message = "IOAPIC"; 562 break; 563 case ACPI_IRQ_MODEL_IOSAPIC: 564 message = "IOSAPIC"; 565 break; 566 case ACPI_IRQ_MODEL_PLATFORM: 567 message = "platform specific model"; 568 break; 569 default: 570 printk(KERN_WARNING PREFIX "Unknown interrupt routing model\n"); 571 return -ENODEV; 572 } 573 574 printk(KERN_INFO PREFIX "Using %s for interrupt routing\n", message); 575 576 arg.integer.value = acpi_irq_model; 577 578 status = acpi_evaluate_object(NULL, "\\_PIC", &arg_list, NULL); 579 if (ACPI_FAILURE(status) && (status != AE_NOT_FOUND)) { 580 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _PIC")); 581 return -ENODEV; 582 } 583 584 return 0; 585} 586 587acpi_native_uint acpi_gbl_permanent_mmap; 588 589 590void __init acpi_early_init(void) 591{ 592 acpi_status status = AE_OK; 593 594 if (acpi_disabled) 595 return; 596 597 printk(KERN_INFO PREFIX "Core revision %08x\n", ACPI_CA_VERSION); 598 599 /* enable workarounds, unless strict ACPI spec. compliance */ 600 if (!acpi_strict) 601 acpi_gbl_enable_interpreter_slack = TRUE; 602 603 acpi_gbl_permanent_mmap = 1; 604 605 status = acpi_reallocate_root_table(); 606 if (ACPI_FAILURE(status)) { 607 printk(KERN_ERR PREFIX 608 "Unable to reallocate ACPI tables\n"); 609 goto error0; 610 } 611 612 status = acpi_initialize_subsystem(); 613 if (ACPI_FAILURE(status)) { 614 printk(KERN_ERR PREFIX 615 "Unable to initialize the ACPI Interpreter\n"); 616 goto error0; 617 } 618 619 status = acpi_load_tables(); 620 if (ACPI_FAILURE(status)) { 621 printk(KERN_ERR PREFIX 622 "Unable to load the System Description Tables\n"); 623 goto error0; 624 } 625 626#ifdef CONFIG_X86 627 if (!acpi_ioapic) { 628 extern u8 acpi_sci_flags; 629 630 /* compatible (0) means level (3) */ 631 if (!(acpi_sci_flags & ACPI_MADT_TRIGGER_MASK)) { 632 acpi_sci_flags &= ~ACPI_MADT_TRIGGER_MASK; 633 acpi_sci_flags |= ACPI_MADT_TRIGGER_LEVEL; 634 } 635 /* Set PIC-mode SCI trigger type */ 636 acpi_pic_sci_set_trigger(acpi_gbl_FADT.sci_interrupt, 637 (acpi_sci_flags & ACPI_MADT_TRIGGER_MASK) >> 2); 638 } else { 639 extern int acpi_sci_override_gsi; 640 /* 641 * now that acpi_gbl_FADT is initialized, 642 * update it with result from INT_SRC_OVR parsing 643 */ 644 acpi_gbl_FADT.sci_interrupt = acpi_sci_override_gsi; 645 } 646#endif 647 648 status = 649 acpi_enable_subsystem(~ 650 (ACPI_NO_HARDWARE_INIT | 651 ACPI_NO_ACPI_ENABLE)); 652 if (ACPI_FAILURE(status)) { 653 printk(KERN_ERR PREFIX "Unable to enable ACPI\n"); 654 goto error0; 655 } 656 657 return; 658 659 error0: 660 disable_acpi(); 661 return; 662} 663 664static int __init acpi_bus_init(void) 665{ 666 int result = 0; 667 acpi_status status = AE_OK; 668 extern acpi_status acpi_os_initialize1(void); 669 670 671 status = acpi_os_initialize1(); 672 673 status = 674 acpi_enable_subsystem(ACPI_NO_HARDWARE_INIT | ACPI_NO_ACPI_ENABLE); 675 if (ACPI_FAILURE(status)) { 676 printk(KERN_ERR PREFIX 677 "Unable to start the ACPI Interpreter\n"); 678 goto error1; 679 } 680 681 if (ACPI_FAILURE(status)) { 682 printk(KERN_ERR PREFIX 683 "Unable to initialize ACPI OS objects\n"); 684 goto error1; 685 } 686#ifdef CONFIG_ACPI_EC 687 /* 688 * ACPI 2.0 requires the EC driver to be loaded and work before 689 * the EC device is found in the namespace (i.e. before acpi_initialize_objects() 690 * is called). 691 * 692 * This is accomplished by looking for the ECDT table, and getting 693 * the EC parameters out of that. 694 */ 695 status = acpi_ec_ecdt_probe(); 696 /* Ignore result. Not having an ECDT is not fatal. */ 697#endif 698 699 status = acpi_initialize_objects(ACPI_FULL_INITIALIZATION); 700 if (ACPI_FAILURE(status)) { 701 printk(KERN_ERR PREFIX "Unable to initialize ACPI objects\n"); 702 goto error1; 703 } 704 705 printk(KERN_INFO PREFIX "Interpreter enabled\n"); 706 707 /* Initialize sleep structures */ 708 acpi_sleep_init(); 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 0; 735 736 /* Mimic structured exception handling */ 737 error1: 738 acpi_terminate(); 739 return -ENODEV; 740} 741 742decl_subsys(acpi, NULL, NULL); 743 744static int __init acpi_init(void) 745{ 746 int result = 0; 747 748 749 if (acpi_disabled) { 750 printk(KERN_INFO PREFIX "Interpreter disabled.\n"); 751 return -ENODEV; 752 } 753 754 result = firmware_register(&acpi_subsys); 755 if (result < 0) 756 printk(KERN_WARNING "%s: firmware_register error: %d\n", 757 __FUNCTION__, result); 758 759 result = acpi_bus_init(); 760 761 if (!result) { 762#ifdef CONFIG_PM_LEGACY 763 if (!PM_IS_ACTIVE()) 764 pm_active = 1; 765 else { 766 printk(KERN_INFO PREFIX 767 "APM is already active, exiting\n"); 768 disable_acpi(); 769 result = -ENODEV; 770 } 771#endif 772 } else 773 disable_acpi(); 774 775 return result; 776} 777 778subsys_initcall(acpi_init); 779