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