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