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