bus.c revision 7daef60721e03809c7e5f8aa8491df4190f6b56f
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("acpi_bus") 43#ifdef CONFIG_X86 44extern void __init acpi_pic_sci_set_trigger(unsigned int irq, u16 trigger); 45#endif 46 47struct fadt_descriptor acpi_fadt; 48EXPORT_SYMBOL(acpi_fadt); 49 50struct acpi_device *acpi_root; 51struct proc_dir_entry *acpi_root_dir; 52EXPORT_SYMBOL(acpi_root_dir); 53 54#define STRUCT_TO_INT(s) (*((int*)&s)) 55 56/* -------------------------------------------------------------------------- 57 Device Management 58 -------------------------------------------------------------------------- */ 59 60int acpi_bus_get_device(acpi_handle handle, struct acpi_device **device) 61{ 62 acpi_status status = AE_OK; 63 64 65 if (!device) 66 return -EINVAL; 67 68 /* TBD: Support fixed-feature devices */ 69 70 status = acpi_get_data(handle, acpi_bus_data_handler, (void **)device); 71 if (ACPI_FAILURE(status) || !*device) { 72 ACPI_EXCEPTION((AE_INFO, status, "No context for object [%p]", handle)); 73 return -ENODEV; 74 } 75 76 return 0; 77} 78 79EXPORT_SYMBOL(acpi_bus_get_device); 80 81int acpi_bus_get_status(struct acpi_device *device) 82{ 83 acpi_status status = AE_OK; 84 unsigned long sta = 0; 85 86 87 if (!device) 88 return -EINVAL; 89 90 /* 91 * Evaluate _STA if present. 92 */ 93 if (device->flags.dynamic_status) { 94 status = 95 acpi_evaluate_integer(device->handle, "_STA", NULL, &sta); 96 if (ACPI_FAILURE(status)) 97 return -ENODEV; 98 STRUCT_TO_INT(device->status) = (int)sta; 99 } 100 101 /* 102 * Otherwise we assume the status of our parent (unless we don't 103 * have one, in which case status is implied). 104 */ 105 else if (device->parent) 106 device->status = device->parent->status; 107 else 108 STRUCT_TO_INT(device->status) = 0x0F; 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", 197 device->kobj.name)); 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->flags.force_power_state) { 205 if (device->power.state == ACPI_STATE_UNKNOWN) 206 acpi_bus_get_power(device->handle, &device->power.state); 207 if (state == device->power.state) { 208 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device is already at D%d\n", 209 state)); 210 return 0; 211 } 212 } 213 if (!device->power.states[state].flags.valid) { 214 printk(KERN_WARNING PREFIX "Device does not support D%d\n", state); 215 return -ENODEV; 216 } 217 if (device->parent && (state < device->parent->power.state)) { 218 printk(KERN_WARNING PREFIX 219 "Cannot set device to a higher-powered" 220 " state than parent\n"); 221 return -ENODEV; 222 } 223 224 /* 225 * Transition Power 226 * ---------------- 227 * On transitions to a high-powered state we first apply power (via 228 * power resources) then evalute _PSx. Conversly for transitions to 229 * a lower-powered state. 230 */ 231 if (state < device->power.state) { 232 if (device->power.flags.power_resources) { 233 result = acpi_power_transition(device, state); 234 if (result) 235 goto end; 236 } 237 if (device->power.states[state].flags.explicit_set) { 238 status = acpi_evaluate_object(device->handle, 239 object_name, NULL, NULL); 240 if (ACPI_FAILURE(status)) { 241 result = -ENODEV; 242 goto end; 243 } 244 } 245 } else { 246 if (device->power.states[state].flags.explicit_set) { 247 status = acpi_evaluate_object(device->handle, 248 object_name, NULL, NULL); 249 if (ACPI_FAILURE(status)) { 250 result = -ENODEV; 251 goto end; 252 } 253 } 254 if (device->power.flags.power_resources) { 255 result = acpi_power_transition(device, state); 256 if (result) 257 goto end; 258 } 259 } 260 261 end: 262 if (result) 263 printk(KERN_WARNING PREFIX 264 "Transitioning device [%s] to D%d\n", 265 device->pnp.bus_id, state); 266 else 267 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 268 "Device [%s] transitioned to D%d\n", 269 device->pnp.bus_id, state)); 270 271 return result; 272} 273 274EXPORT_SYMBOL(acpi_bus_set_power); 275 276/* -------------------------------------------------------------------------- 277 Event Management 278 -------------------------------------------------------------------------- */ 279 280static DEFINE_SPINLOCK(acpi_bus_event_lock); 281 282LIST_HEAD(acpi_bus_event_list); 283DECLARE_WAIT_QUEUE_HEAD(acpi_bus_event_queue); 284 285extern int event_is_open; 286 287int acpi_bus_generate_event(struct acpi_device *device, u8 type, int data) 288{ 289 struct acpi_bus_event *event = NULL; 290 unsigned long flags = 0; 291 292 293 if (!device) 294 return -EINVAL; 295 296 /* drop event on the floor if no one's listening */ 297 if (!event_is_open) 298 return 0; 299 300 event = kmalloc(sizeof(struct acpi_bus_event), GFP_ATOMIC); 301 if (!event) 302 return -ENOMEM; 303 304 strcpy(event->device_class, device->pnp.device_class); 305 strcpy(event->bus_id, device->pnp.bus_id); 306 event->type = type; 307 event->data = data; 308 309 spin_lock_irqsave(&acpi_bus_event_lock, flags); 310 list_add_tail(&event->node, &acpi_bus_event_list); 311 spin_unlock_irqrestore(&acpi_bus_event_lock, flags); 312 313 wake_up_interruptible(&acpi_bus_event_queue); 314 315 return 0; 316} 317 318EXPORT_SYMBOL(acpi_bus_generate_event); 319 320int acpi_bus_receive_event(struct acpi_bus_event *event) 321{ 322 unsigned long flags = 0; 323 struct acpi_bus_event *entry = NULL; 324 325 DECLARE_WAITQUEUE(wait, current); 326 327 328 if (!event) 329 return -EINVAL; 330 331 if (list_empty(&acpi_bus_event_list)) { 332 333 set_current_state(TASK_INTERRUPTIBLE); 334 add_wait_queue(&acpi_bus_event_queue, &wait); 335 336 if (list_empty(&acpi_bus_event_list)) 337 schedule(); 338 339 remove_wait_queue(&acpi_bus_event_queue, &wait); 340 set_current_state(TASK_RUNNING); 341 342 if (signal_pending(current)) 343 return -ERESTARTSYS; 344 } 345 346 spin_lock_irqsave(&acpi_bus_event_lock, flags); 347 entry = 348 list_entry(acpi_bus_event_list.next, struct acpi_bus_event, node); 349 if (entry) 350 list_del(&entry->node); 351 spin_unlock_irqrestore(&acpi_bus_event_lock, flags); 352 353 if (!entry) 354 return -ENODEV; 355 356 memcpy(event, entry, sizeof(struct acpi_bus_event)); 357 358 kfree(entry); 359 360 return 0; 361} 362 363EXPORT_SYMBOL(acpi_bus_receive_event); 364 365/* -------------------------------------------------------------------------- 366 Notification Handling 367 -------------------------------------------------------------------------- */ 368 369static int 370acpi_bus_check_device(struct acpi_device *device, int *status_changed) 371{ 372 acpi_status status = 0; 373 struct acpi_device_status old_status; 374 375 376 if (!device) 377 return -EINVAL; 378 379 if (status_changed) 380 *status_changed = 0; 381 382 old_status = device->status; 383 384 /* 385 * Make sure this device's parent is present before we go about 386 * messing with the device. 387 */ 388 if (device->parent && !device->parent->status.present) { 389 device->status = device->parent->status; 390 if (STRUCT_TO_INT(old_status) != STRUCT_TO_INT(device->status)) { 391 if (status_changed) 392 *status_changed = 1; 393 } 394 return 0; 395 } 396 397 status = acpi_bus_get_status(device); 398 if (ACPI_FAILURE(status)) 399 return -ENODEV; 400 401 if (STRUCT_TO_INT(old_status) == STRUCT_TO_INT(device->status)) 402 return 0; 403 404 if (status_changed) 405 *status_changed = 1; 406 407 /* 408 * Device Insertion/Removal 409 */ 410 if ((device->status.present) && !(old_status.present)) { 411 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device insertion detected\n")); 412 /* TBD: Handle device insertion */ 413 } else if (!(device->status.present) && (old_status.present)) { 414 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device removal detected\n")); 415 /* TBD: Handle device removal */ 416 } 417 418 return 0; 419} 420 421static int acpi_bus_check_scope(struct acpi_device *device) 422{ 423 int result = 0; 424 int status_changed = 0; 425 426 427 if (!device) 428 return -EINVAL; 429 430 /* Status Change? */ 431 result = acpi_bus_check_device(device, &status_changed); 432 if (result) 433 return result; 434 435 if (!status_changed) 436 return 0; 437 438 /* 439 * TBD: Enumerate child devices within this device's scope and 440 * run acpi_bus_check_device()'s on them. 441 */ 442 443 return 0; 444} 445 446/** 447 * acpi_bus_notify 448 * --------------- 449 * Callback for all 'system-level' device notifications (values 0x00-0x7F). 450 */ 451static void acpi_bus_notify(acpi_handle handle, u32 type, void *data) 452{ 453 int result = 0; 454 struct acpi_device *device = NULL; 455 456 457 if (acpi_bus_get_device(handle, &device)) 458 return; 459 460 switch (type) { 461 462 case ACPI_NOTIFY_BUS_CHECK: 463 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 464 "Received BUS CHECK notification for device [%s]\n", 465 device->pnp.bus_id)); 466 result = acpi_bus_check_scope(device); 467 /* 468 * TBD: We'll need to outsource certain events to non-ACPI 469 * drivers via the device manager (device.c). 470 */ 471 break; 472 473 case ACPI_NOTIFY_DEVICE_CHECK: 474 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 475 "Received DEVICE CHECK notification for device [%s]\n", 476 device->pnp.bus_id)); 477 result = acpi_bus_check_device(device, NULL); 478 /* 479 * TBD: We'll need to outsource certain events to non-ACPI 480 * drivers via the device manager (device.c). 481 */ 482 break; 483 484 case ACPI_NOTIFY_DEVICE_WAKE: 485 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 486 "Received DEVICE WAKE notification for device [%s]\n", 487 device->pnp.bus_id)); 488 /* TBD */ 489 break; 490 491 case ACPI_NOTIFY_EJECT_REQUEST: 492 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 493 "Received EJECT REQUEST notification for device [%s]\n", 494 device->pnp.bus_id)); 495 /* TBD */ 496 break; 497 498 case ACPI_NOTIFY_DEVICE_CHECK_LIGHT: 499 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 500 "Received DEVICE CHECK LIGHT notification for device [%s]\n", 501 device->pnp.bus_id)); 502 /* TBD: Exactly what does 'light' mean? */ 503 break; 504 505 case ACPI_NOTIFY_FREQUENCY_MISMATCH: 506 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 507 "Received FREQUENCY MISMATCH notification for device [%s]\n", 508 device->pnp.bus_id)); 509 /* TBD */ 510 break; 511 512 case ACPI_NOTIFY_BUS_MODE_MISMATCH: 513 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 514 "Received BUS MODE MISMATCH notification for device [%s]\n", 515 device->pnp.bus_id)); 516 /* TBD */ 517 break; 518 519 case ACPI_NOTIFY_POWER_FAULT: 520 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 521 "Received POWER FAULT notification for device [%s]\n", 522 device->pnp.bus_id)); 523 /* TBD */ 524 break; 525 526 default: 527 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 528 "Received unknown/unsupported notification [%08x]\n", 529 type)); 530 break; 531 } 532 533 return; 534} 535 536/* -------------------------------------------------------------------------- 537 Initialization/Cleanup 538 -------------------------------------------------------------------------- */ 539 540static int __init acpi_bus_init_irq(void) 541{ 542 acpi_status status = AE_OK; 543 union acpi_object arg = { ACPI_TYPE_INTEGER }; 544 struct acpi_object_list arg_list = { 1, &arg }; 545 char *message = NULL; 546 547 548 /* 549 * Let the system know what interrupt model we are using by 550 * evaluating the \_PIC object, if exists. 551 */ 552 553 switch (acpi_irq_model) { 554 case ACPI_IRQ_MODEL_PIC: 555 message = "PIC"; 556 break; 557 case ACPI_IRQ_MODEL_IOAPIC: 558 message = "IOAPIC"; 559 break; 560 case ACPI_IRQ_MODEL_IOSAPIC: 561 message = "IOSAPIC"; 562 break; 563 default: 564 printk(KERN_WARNING PREFIX "Unknown interrupt routing model\n"); 565 return -ENODEV; 566 } 567 568 printk(KERN_INFO PREFIX "Using %s for interrupt routing\n", message); 569 570 arg.integer.value = acpi_irq_model; 571 572 status = acpi_evaluate_object(NULL, "\\_PIC", &arg_list, NULL); 573 if (ACPI_FAILURE(status) && (status != AE_NOT_FOUND)) { 574 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _PIC")); 575 return -ENODEV; 576 } 577 578 return 0; 579} 580 581void __init acpi_early_init(void) 582{ 583 acpi_status status = AE_OK; 584 struct acpi_buffer buffer = { sizeof(acpi_fadt), &acpi_fadt }; 585 586 587 if (acpi_disabled) 588 return; 589 590 printk(KERN_INFO PREFIX "Core revision %08x\n", ACPI_CA_VERSION); 591 592 /* enable workarounds, unless strict ACPI spec. compliance */ 593 if (!acpi_strict) 594 acpi_gbl_enable_interpreter_slack = TRUE; 595 596 status = acpi_initialize_subsystem(); 597 if (ACPI_FAILURE(status)) { 598 printk(KERN_ERR PREFIX 599 "Unable to initialize the ACPI Interpreter\n"); 600 goto error0; 601 } 602 603 status = acpi_load_tables(); 604 if (ACPI_FAILURE(status)) { 605 printk(KERN_ERR PREFIX 606 "Unable to load the System Description Tables\n"); 607 goto error0; 608 } 609 610 /* 611 * Get a separate copy of the FADT for use by other drivers. 612 */ 613 status = acpi_get_table(ACPI_TABLE_ID_FADT, 1, &buffer); 614 if (ACPI_FAILURE(status)) { 615 printk(KERN_ERR PREFIX "Unable to get the FADT\n"); 616 goto error0; 617 } 618#ifdef CONFIG_X86 619 if (!acpi_ioapic) { 620 extern acpi_interrupt_flags acpi_sci_flags; 621 622 /* compatible (0) means level (3) */ 623 if (acpi_sci_flags.trigger == 0) 624 acpi_sci_flags.trigger = 3; 625 626 /* Set PIC-mode SCI trigger type */ 627 acpi_pic_sci_set_trigger(acpi_fadt.sci_int, 628 acpi_sci_flags.trigger); 629 } else { 630 extern int acpi_sci_override_gsi; 631 /* 632 * now that acpi_fadt is initialized, 633 * update it with result from INT_SRC_OVR parsing 634 */ 635 acpi_fadt.sci_int = acpi_sci_override_gsi; 636 } 637#endif 638 639 status = 640 acpi_enable_subsystem(~ 641 (ACPI_NO_HARDWARE_INIT | 642 ACPI_NO_ACPI_ENABLE)); 643 if (ACPI_FAILURE(status)) { 644 printk(KERN_ERR PREFIX "Unable to enable ACPI\n"); 645 goto error0; 646 } 647 648 return; 649 650 error0: 651 disable_acpi(); 652 return; 653} 654 655static int __init acpi_bus_init(void) 656{ 657 int result = 0; 658 acpi_status status = AE_OK; 659 extern acpi_status acpi_os_initialize1(void); 660 661 662 status = acpi_os_initialize1(); 663 664 status = 665 acpi_enable_subsystem(ACPI_NO_HARDWARE_INIT | ACPI_NO_ACPI_ENABLE); 666 if (ACPI_FAILURE(status)) { 667 printk(KERN_ERR PREFIX 668 "Unable to start the ACPI Interpreter\n"); 669 goto error1; 670 } 671 672 if (ACPI_FAILURE(status)) { 673 printk(KERN_ERR PREFIX 674 "Unable to initialize ACPI OS objects\n"); 675 goto error1; 676 } 677#ifdef CONFIG_ACPI_EC 678 /* 679 * ACPI 2.0 requires the EC driver to be loaded and work before 680 * the EC device is found in the namespace (i.e. before acpi_initialize_objects() 681 * is called). 682 * 683 * This is accomplished by looking for the ECDT table, and getting 684 * the EC parameters out of that. 685 */ 686 status = acpi_ec_ecdt_probe(); 687 /* Ignore result. Not having an ECDT is not fatal. */ 688#endif 689 690 status = acpi_initialize_objects(ACPI_FULL_INITIALIZATION); 691 if (ACPI_FAILURE(status)) { 692 printk(KERN_ERR PREFIX "Unable to initialize ACPI objects\n"); 693 goto error1; 694 } 695 696 printk(KERN_INFO PREFIX "Interpreter enabled\n"); 697 698 /* 699 * Get the system interrupt model and evaluate \_PIC. 700 */ 701 result = acpi_bus_init_irq(); 702 if (result) 703 goto error1; 704 705 /* 706 * Register the for all standard device notifications. 707 */ 708 status = 709 acpi_install_notify_handler(ACPI_ROOT_OBJECT, ACPI_SYSTEM_NOTIFY, 710 &acpi_bus_notify, NULL); 711 if (ACPI_FAILURE(status)) { 712 printk(KERN_ERR PREFIX 713 "Unable to register for device notifications\n"); 714 goto error1; 715 } 716 717 /* 718 * Create the top ACPI proc directory 719 */ 720 acpi_root_dir = proc_mkdir(ACPI_BUS_FILE_ROOT, NULL); 721 722 return 0; 723 724 /* Mimic structured exception handling */ 725 error1: 726 acpi_terminate(); 727 return -ENODEV; 728} 729 730decl_subsys(acpi, NULL, NULL); 731 732static int __init acpi_init(void) 733{ 734 int result = 0; 735 736 737 if (acpi_disabled) { 738 printk(KERN_INFO PREFIX "Interpreter disabled.\n"); 739 return -ENODEV; 740 } 741 742 result = firmware_register(&acpi_subsys); 743 if (result < 0) 744 printk(KERN_WARNING "%s: firmware_register error: %d\n", 745 __FUNCTION__, result); 746 747 result = acpi_bus_init(); 748 749 if (!result) { 750#ifdef CONFIG_PM_LEGACY 751 if (!PM_IS_ACTIVE()) 752 pm_active = 1; 753 else { 754 printk(KERN_INFO PREFIX 755 "APM is already active, exiting\n"); 756 disable_acpi(); 757 result = -ENODEV; 758 } 759#endif 760 } else 761 disable_acpi(); 762 763 return result; 764} 765 766subsys_initcall(acpi_init); 767