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