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 #include <linux/slab.h> 36 #ifdef CONFIG_X86 37 #include <asm/mpspec.h> 38 #endif 39 #include <linux/pci.h> 40 #include <acpi/acpi_bus.h> 41 #include <acpi/acpi_drivers.h> 42 #include <linux/dmi.h> 43 44 #include "internal.h" 45 46 #define _COMPONENT ACPI_BUS_COMPONENT 47 ACPI_MODULE_NAME("bus"); 48 49 struct acpi_device *acpi_root; 50 struct proc_dir_entry *acpi_root_dir; 51 EXPORT_SYMBOL(acpi_root_dir); 52 53 #define STRUCT_TO_INT(s) (*((int*)&s)) 54 55 56 #ifdef CONFIG_X86 57 static int set_copy_dsdt(const struct dmi_system_id *id) 58 { 59 printk(KERN_NOTICE "%s detected - " 60 "force copy of DSDT to local memory\n", id->ident); 61 acpi_gbl_copy_dsdt_locally = 1; 62 return 0; 63 } 64 65 static struct dmi_system_id dsdt_dmi_table[] __initdata = { 66 /* 67 * Invoke DSDT corruption work-around on all Toshiba Satellite. 68 * https://bugzilla.kernel.org/show_bug.cgi?id=14679 69 */ 70 { 71 .callback = set_copy_dsdt, 72 .ident = "TOSHIBA Satellite", 73 .matches = { 74 DMI_MATCH(DMI_SYS_VENDOR, "TOSHIBA"), 75 DMI_MATCH(DMI_PRODUCT_NAME, "Satellite"), 76 }, 77 }, 78 {} 79 }; 80 #else 81 static struct dmi_system_id dsdt_dmi_table[] __initdata = { 82 {} 83 }; 84 #endif 85 86 /* -------------------------------------------------------------------------- 87 Device Management 88 -------------------------------------------------------------------------- */ 89 90 int acpi_bus_get_device(acpi_handle handle, struct acpi_device **device) 91 { 92 acpi_status status = AE_OK; 93 94 95 if (!device) 96 return -EINVAL; 97 98 /* TBD: Support fixed-feature devices */ 99 100 status = acpi_get_data(handle, acpi_bus_data_handler, (void **)device); 101 if (ACPI_FAILURE(status) || !*device) { 102 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No context for object [%p]\n", 103 handle)); 104 return -ENODEV; 105 } 106 107 return 0; 108 } 109 110 EXPORT_SYMBOL(acpi_bus_get_device); 111 112 acpi_status acpi_bus_get_status_handle(acpi_handle handle, 113 unsigned long long *sta) 114 { 115 acpi_status status; 116 117 status = acpi_evaluate_integer(handle, "_STA", NULL, sta); 118 if (ACPI_SUCCESS(status)) 119 return AE_OK; 120 121 if (status == AE_NOT_FOUND) { 122 *sta = ACPI_STA_DEVICE_PRESENT | ACPI_STA_DEVICE_ENABLED | 123 ACPI_STA_DEVICE_UI | ACPI_STA_DEVICE_FUNCTIONING; 124 return AE_OK; 125 } 126 return status; 127 } 128 129 int acpi_bus_get_status(struct acpi_device *device) 130 { 131 acpi_status status; 132 unsigned long long sta; 133 134 status = acpi_bus_get_status_handle(device->handle, &sta); 135 if (ACPI_FAILURE(status)) 136 return -ENODEV; 137 138 STRUCT_TO_INT(device->status) = (int) sta; 139 140 if (device->status.functional && !device->status.present) { 141 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device [%s] status [%08x]: " 142 "functional but not present;\n", 143 device->pnp.bus_id, 144 (u32) STRUCT_TO_INT(device->status))); 145 } 146 147 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device [%s] status [%08x]\n", 148 device->pnp.bus_id, 149 (u32) STRUCT_TO_INT(device->status))); 150 return 0; 151 } 152 EXPORT_SYMBOL(acpi_bus_get_status); 153 154 void acpi_bus_private_data_handler(acpi_handle handle, 155 void *context) 156 { 157 return; 158 } 159 EXPORT_SYMBOL(acpi_bus_private_data_handler); 160 161 int acpi_bus_get_private_data(acpi_handle handle, void **data) 162 { 163 acpi_status status = AE_OK; 164 165 if (!*data) 166 return -EINVAL; 167 168 status = acpi_get_data(handle, acpi_bus_private_data_handler, data); 169 if (ACPI_FAILURE(status) || !*data) { 170 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No context for object [%p]\n", 171 handle)); 172 return -ENODEV; 173 } 174 175 return 0; 176 } 177 EXPORT_SYMBOL(acpi_bus_get_private_data); 178 179 /* -------------------------------------------------------------------------- 180 Power Management 181 -------------------------------------------------------------------------- */ 182 183 static int __acpi_bus_get_power(struct acpi_device *device, int *state) 184 { 185 int result = 0; 186 acpi_status status = 0; 187 unsigned long long psc = 0; 188 189 if (!device || !state) 190 return -EINVAL; 191 192 *state = ACPI_STATE_UNKNOWN; 193 194 if (device->flags.power_manageable) { 195 /* 196 * Get the device's power state either directly (via _PSC) or 197 * indirectly (via power resources). 198 */ 199 if (device->power.flags.power_resources) { 200 result = acpi_power_get_inferred_state(device, state); 201 if (result) 202 return result; 203 } else if (device->power.flags.explicit_get) { 204 status = acpi_evaluate_integer(device->handle, "_PSC", 205 NULL, &psc); 206 if (ACPI_FAILURE(status)) 207 return -ENODEV; 208 *state = (int)psc; 209 } 210 } else { 211 /* TBD: Non-recursive algorithm for walking up hierarchy. */ 212 *state = device->parent ? 213 device->parent->power.state : ACPI_STATE_D0; 214 } 215 216 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device [%s] power state is D%d\n", 217 device->pnp.bus_id, *state)); 218 219 return 0; 220 } 221 222 223 static int __acpi_bus_set_power(struct acpi_device *device, int state) 224 { 225 int result = 0; 226 acpi_status status = AE_OK; 227 char object_name[5] = { '_', 'P', 'S', '0' + state, '\0' }; 228 229 if (!device || (state < ACPI_STATE_D0) || (state > ACPI_STATE_D3)) 230 return -EINVAL; 231 232 /* Make sure this is a valid target state */ 233 234 if (state == device->power.state) { 235 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device is already at D%d\n", 236 state)); 237 return 0; 238 } 239 240 if (!device->power.states[state].flags.valid) { 241 printk(KERN_WARNING PREFIX "Device does not support D%d\n", state); 242 return -ENODEV; 243 } 244 if (device->parent && (state < device->parent->power.state)) { 245 printk(KERN_WARNING PREFIX 246 "Cannot set device to a higher-powered" 247 " state than parent\n"); 248 return -ENODEV; 249 } 250 251 /* 252 * Transition Power 253 * ---------------- 254 * On transitions to a high-powered state we first apply power (via 255 * power resources) then evalute _PSx. Conversly for transitions to 256 * a lower-powered state. 257 */ 258 if (state < device->power.state) { 259 if (device->power.flags.power_resources) { 260 result = acpi_power_transition(device, state); 261 if (result) 262 goto end; 263 } 264 if (device->power.states[state].flags.explicit_set) { 265 status = acpi_evaluate_object(device->handle, 266 object_name, NULL, NULL); 267 if (ACPI_FAILURE(status)) { 268 result = -ENODEV; 269 goto end; 270 } 271 } 272 } else { 273 if (device->power.states[state].flags.explicit_set) { 274 status = acpi_evaluate_object(device->handle, 275 object_name, NULL, NULL); 276 if (ACPI_FAILURE(status)) { 277 result = -ENODEV; 278 goto end; 279 } 280 } 281 if (device->power.flags.power_resources) { 282 result = acpi_power_transition(device, state); 283 if (result) 284 goto end; 285 } 286 } 287 288 end: 289 if (result) 290 printk(KERN_WARNING PREFIX 291 "Device [%s] failed to transition to D%d\n", 292 device->pnp.bus_id, state); 293 else { 294 device->power.state = state; 295 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 296 "Device [%s] transitioned to D%d\n", 297 device->pnp.bus_id, state)); 298 } 299 300 return result; 301 } 302 303 304 int acpi_bus_set_power(acpi_handle handle, int state) 305 { 306 struct acpi_device *device; 307 int result; 308 309 result = acpi_bus_get_device(handle, &device); 310 if (result) 311 return result; 312 313 if (!device->flags.power_manageable) { 314 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 315 "Device [%s] is not power manageable\n", 316 dev_name(&device->dev))); 317 return -ENODEV; 318 } 319 320 return __acpi_bus_set_power(device, state); 321 } 322 EXPORT_SYMBOL(acpi_bus_set_power); 323 324 325 int acpi_bus_init_power(struct acpi_device *device) 326 { 327 int state; 328 int result; 329 330 if (!device) 331 return -EINVAL; 332 333 device->power.state = ACPI_STATE_UNKNOWN; 334 335 result = __acpi_bus_get_power(device, &state); 336 if (result) 337 return result; 338 339 if (device->power.flags.power_resources) 340 result = acpi_power_on_resources(device, state); 341 342 if (!result) 343 device->power.state = state; 344 345 return result; 346 } 347 348 349 int acpi_bus_update_power(acpi_handle handle, int *state_p) 350 { 351 struct acpi_device *device; 352 int state; 353 int result; 354 355 result = acpi_bus_get_device(handle, &device); 356 if (result) 357 return result; 358 359 result = __acpi_bus_get_power(device, &state); 360 if (result) 361 return result; 362 363 result = __acpi_bus_set_power(device, state); 364 if (!result && state_p) 365 *state_p = state; 366 367 return result; 368 } 369 EXPORT_SYMBOL_GPL(acpi_bus_update_power); 370 371 372 bool acpi_bus_power_manageable(acpi_handle handle) 373 { 374 struct acpi_device *device; 375 int result; 376 377 result = acpi_bus_get_device(handle, &device); 378 return result ? false : device->flags.power_manageable; 379 } 380 381 EXPORT_SYMBOL(acpi_bus_power_manageable); 382 383 bool acpi_bus_can_wakeup(acpi_handle handle) 384 { 385 struct acpi_device *device; 386 int result; 387 388 result = acpi_bus_get_device(handle, &device); 389 return result ? false : device->wakeup.flags.valid; 390 } 391 392 EXPORT_SYMBOL(acpi_bus_can_wakeup); 393 394 static void acpi_print_osc_error(acpi_handle handle, 395 struct acpi_osc_context *context, char *error) 396 { 397 struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER}; 398 int i; 399 400 if (ACPI_FAILURE(acpi_get_name(handle, ACPI_FULL_PATHNAME, &buffer))) 401 printk(KERN_DEBUG "%s\n", error); 402 else { 403 printk(KERN_DEBUG "%s:%s\n", (char *)buffer.pointer, error); 404 kfree(buffer.pointer); 405 } 406 printk(KERN_DEBUG"_OSC request data:"); 407 for (i = 0; i < context->cap.length; i += sizeof(u32)) 408 printk("%x ", *((u32 *)(context->cap.pointer + i))); 409 printk("\n"); 410 } 411 412 static acpi_status acpi_str_to_uuid(char *str, u8 *uuid) 413 { 414 int i; 415 static int opc_map_to_uuid[16] = {6, 4, 2, 0, 11, 9, 16, 14, 19, 21, 416 24, 26, 28, 30, 32, 34}; 417 418 if (strlen(str) != 36) 419 return AE_BAD_PARAMETER; 420 for (i = 0; i < 36; i++) { 421 if (i == 8 || i == 13 || i == 18 || i == 23) { 422 if (str[i] != '-') 423 return AE_BAD_PARAMETER; 424 } else if (!isxdigit(str[i])) 425 return AE_BAD_PARAMETER; 426 } 427 for (i = 0; i < 16; i++) { 428 uuid[i] = hex_to_bin(str[opc_map_to_uuid[i]]) << 4; 429 uuid[i] |= hex_to_bin(str[opc_map_to_uuid[i] + 1]); 430 } 431 return AE_OK; 432 } 433 434 acpi_status acpi_run_osc(acpi_handle handle, struct acpi_osc_context *context) 435 { 436 acpi_status status; 437 struct acpi_object_list input; 438 union acpi_object in_params[4]; 439 union acpi_object *out_obj; 440 u8 uuid[16]; 441 u32 errors; 442 struct acpi_buffer output = {ACPI_ALLOCATE_BUFFER, NULL}; 443 444 if (!context) 445 return AE_ERROR; 446 if (ACPI_FAILURE(acpi_str_to_uuid(context->uuid_str, uuid))) 447 return AE_ERROR; 448 context->ret.length = ACPI_ALLOCATE_BUFFER; 449 context->ret.pointer = NULL; 450 451 /* Setting up input parameters */ 452 input.count = 4; 453 input.pointer = in_params; 454 in_params[0].type = ACPI_TYPE_BUFFER; 455 in_params[0].buffer.length = 16; 456 in_params[0].buffer.pointer = uuid; 457 in_params[1].type = ACPI_TYPE_INTEGER; 458 in_params[1].integer.value = context->rev; 459 in_params[2].type = ACPI_TYPE_INTEGER; 460 in_params[2].integer.value = context->cap.length/sizeof(u32); 461 in_params[3].type = ACPI_TYPE_BUFFER; 462 in_params[3].buffer.length = context->cap.length; 463 in_params[3].buffer.pointer = context->cap.pointer; 464 465 status = acpi_evaluate_object(handle, "_OSC", &input, &output); 466 if (ACPI_FAILURE(status)) 467 return status; 468 469 if (!output.length) 470 return AE_NULL_OBJECT; 471 472 out_obj = output.pointer; 473 if (out_obj->type != ACPI_TYPE_BUFFER 474 || out_obj->buffer.length != context->cap.length) { 475 acpi_print_osc_error(handle, context, 476 "_OSC evaluation returned wrong type"); 477 status = AE_TYPE; 478 goto out_kfree; 479 } 480 /* Need to ignore the bit0 in result code */ 481 errors = *((u32 *)out_obj->buffer.pointer) & ~(1 << 0); 482 if (errors) { 483 if (errors & OSC_REQUEST_ERROR) 484 acpi_print_osc_error(handle, context, 485 "_OSC request failed"); 486 if (errors & OSC_INVALID_UUID_ERROR) 487 acpi_print_osc_error(handle, context, 488 "_OSC invalid UUID"); 489 if (errors & OSC_INVALID_REVISION_ERROR) 490 acpi_print_osc_error(handle, context, 491 "_OSC invalid revision"); 492 if (errors & OSC_CAPABILITIES_MASK_ERROR) { 493 if (((u32 *)context->cap.pointer)[OSC_QUERY_TYPE] 494 & OSC_QUERY_ENABLE) 495 goto out_success; 496 status = AE_SUPPORT; 497 goto out_kfree; 498 } 499 status = AE_ERROR; 500 goto out_kfree; 501 } 502 out_success: 503 context->ret.length = out_obj->buffer.length; 504 context->ret.pointer = kmalloc(context->ret.length, GFP_KERNEL); 505 if (!context->ret.pointer) { 506 status = AE_NO_MEMORY; 507 goto out_kfree; 508 } 509 memcpy(context->ret.pointer, out_obj->buffer.pointer, 510 context->ret.length); 511 status = AE_OK; 512 513 out_kfree: 514 kfree(output.pointer); 515 if (status != AE_OK) 516 context->ret.pointer = NULL; 517 return status; 518 } 519 EXPORT_SYMBOL(acpi_run_osc); 520 521 static u8 sb_uuid_str[] = "0811B06E-4A27-44F9-8D60-3CBBC22E7B48"; 522 static void acpi_bus_osc_support(void) 523 { 524 u32 capbuf[2]; 525 struct acpi_osc_context context = { 526 .uuid_str = sb_uuid_str, 527 .rev = 1, 528 .cap.length = 8, 529 .cap.pointer = capbuf, 530 }; 531 acpi_handle handle; 532 533 capbuf[OSC_QUERY_TYPE] = OSC_QUERY_ENABLE; 534 capbuf[OSC_SUPPORT_TYPE] = OSC_SB_PR3_SUPPORT; /* _PR3 is in use */ 535 #if defined(CONFIG_ACPI_PROCESSOR_AGGREGATOR) ||\ 536 defined(CONFIG_ACPI_PROCESSOR_AGGREGATOR_MODULE) 537 capbuf[OSC_SUPPORT_TYPE] |= OSC_SB_PAD_SUPPORT; 538 #endif 539 540 #if defined(CONFIG_ACPI_PROCESSOR) || defined(CONFIG_ACPI_PROCESSOR_MODULE) 541 capbuf[OSC_SUPPORT_TYPE] |= OSC_SB_PPC_OST_SUPPORT; 542 #endif 543 if (ACPI_FAILURE(acpi_get_handle(NULL, "\\_SB", &handle))) 544 return; 545 if (ACPI_SUCCESS(acpi_run_osc(handle, &context))) 546 kfree(context.ret.pointer); 547 /* do we need to check the returned cap? Sounds no */ 548 } 549 550 /* -------------------------------------------------------------------------- 551 Event Management 552 -------------------------------------------------------------------------- */ 553 554 #ifdef CONFIG_ACPI_PROC_EVENT 555 static DEFINE_SPINLOCK(acpi_bus_event_lock); 556 557 LIST_HEAD(acpi_bus_event_list); 558 DECLARE_WAIT_QUEUE_HEAD(acpi_bus_event_queue); 559 560 extern int event_is_open; 561 562 int acpi_bus_generate_proc_event4(const char *device_class, const char *bus_id, u8 type, int data) 563 { 564 struct acpi_bus_event *event; 565 unsigned long flags = 0; 566 567 /* drop event on the floor if no one's listening */ 568 if (!event_is_open) 569 return 0; 570 571 event = kzalloc(sizeof(struct acpi_bus_event), GFP_ATOMIC); 572 if (!event) 573 return -ENOMEM; 574 575 strcpy(event->device_class, device_class); 576 strcpy(event->bus_id, bus_id); 577 event->type = type; 578 event->data = data; 579 580 spin_lock_irqsave(&acpi_bus_event_lock, flags); 581 list_add_tail(&event->node, &acpi_bus_event_list); 582 spin_unlock_irqrestore(&acpi_bus_event_lock, flags); 583 584 wake_up_interruptible(&acpi_bus_event_queue); 585 586 return 0; 587 588 } 589 590 EXPORT_SYMBOL_GPL(acpi_bus_generate_proc_event4); 591 592 int acpi_bus_generate_proc_event(struct acpi_device *device, u8 type, int data) 593 { 594 if (!device) 595 return -EINVAL; 596 return acpi_bus_generate_proc_event4(device->pnp.device_class, 597 device->pnp.bus_id, type, data); 598 } 599 600 EXPORT_SYMBOL(acpi_bus_generate_proc_event); 601 602 int acpi_bus_receive_event(struct acpi_bus_event *event) 603 { 604 unsigned long flags = 0; 605 struct acpi_bus_event *entry = NULL; 606 607 DECLARE_WAITQUEUE(wait, current); 608 609 610 if (!event) 611 return -EINVAL; 612 613 if (list_empty(&acpi_bus_event_list)) { 614 615 set_current_state(TASK_INTERRUPTIBLE); 616 add_wait_queue(&acpi_bus_event_queue, &wait); 617 618 if (list_empty(&acpi_bus_event_list)) 619 schedule(); 620 621 remove_wait_queue(&acpi_bus_event_queue, &wait); 622 set_current_state(TASK_RUNNING); 623 624 if (signal_pending(current)) 625 return -ERESTARTSYS; 626 } 627 628 spin_lock_irqsave(&acpi_bus_event_lock, flags); 629 if (!list_empty(&acpi_bus_event_list)) { 630 entry = list_entry(acpi_bus_event_list.next, 631 struct acpi_bus_event, node); 632 list_del(&entry->node); 633 } 634 spin_unlock_irqrestore(&acpi_bus_event_lock, flags); 635 636 if (!entry) 637 return -ENODEV; 638 639 memcpy(event, entry, sizeof(struct acpi_bus_event)); 640 641 kfree(entry); 642 643 return 0; 644 } 645 646 #endif /* CONFIG_ACPI_PROC_EVENT */ 647 648 /* -------------------------------------------------------------------------- 649 Notification Handling 650 -------------------------------------------------------------------------- */ 651 652 static void acpi_bus_check_device(acpi_handle handle) 653 { 654 struct acpi_device *device; 655 acpi_status status; 656 struct acpi_device_status old_status; 657 658 if (acpi_bus_get_device(handle, &device)) 659 return; 660 if (!device) 661 return; 662 663 old_status = device->status; 664 665 /* 666 * Make sure this device's parent is present before we go about 667 * messing with the device. 668 */ 669 if (device->parent && !device->parent->status.present) { 670 device->status = device->parent->status; 671 return; 672 } 673 674 status = acpi_bus_get_status(device); 675 if (ACPI_FAILURE(status)) 676 return; 677 678 if (STRUCT_TO_INT(old_status) == STRUCT_TO_INT(device->status)) 679 return; 680 681 /* 682 * Device Insertion/Removal 683 */ 684 if ((device->status.present) && !(old_status.present)) { 685 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device insertion detected\n")); 686 /* TBD: Handle device insertion */ 687 } else if (!(device->status.present) && (old_status.present)) { 688 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device removal detected\n")); 689 /* TBD: Handle device removal */ 690 } 691 } 692 693 static void acpi_bus_check_scope(acpi_handle handle) 694 { 695 /* Status Change? */ 696 acpi_bus_check_device(handle); 697 698 /* 699 * TBD: Enumerate child devices within this device's scope and 700 * run acpi_bus_check_device()'s on them. 701 */ 702 } 703 704 static BLOCKING_NOTIFIER_HEAD(acpi_bus_notify_list); 705 int register_acpi_bus_notifier(struct notifier_block *nb) 706 { 707 return blocking_notifier_chain_register(&acpi_bus_notify_list, nb); 708 } 709 EXPORT_SYMBOL_GPL(register_acpi_bus_notifier); 710 711 void unregister_acpi_bus_notifier(struct notifier_block *nb) 712 { 713 blocking_notifier_chain_unregister(&acpi_bus_notify_list, nb); 714 } 715 EXPORT_SYMBOL_GPL(unregister_acpi_bus_notifier); 716 717 /** 718 * acpi_bus_notify 719 * --------------- 720 * Callback for all 'system-level' device notifications (values 0x00-0x7F). 721 */ 722 static void acpi_bus_notify(acpi_handle handle, u32 type, void *data) 723 { 724 struct acpi_device *device = NULL; 725 struct acpi_driver *driver; 726 727 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Notification %#02x to handle %p\n", 728 type, handle)); 729 730 blocking_notifier_call_chain(&acpi_bus_notify_list, 731 type, (void *)handle); 732 733 switch (type) { 734 735 case ACPI_NOTIFY_BUS_CHECK: 736 acpi_bus_check_scope(handle); 737 /* 738 * TBD: We'll need to outsource certain events to non-ACPI 739 * drivers via the device manager (device.c). 740 */ 741 break; 742 743 case ACPI_NOTIFY_DEVICE_CHECK: 744 acpi_bus_check_device(handle); 745 /* 746 * TBD: We'll need to outsource certain events to non-ACPI 747 * drivers via the device manager (device.c). 748 */ 749 break; 750 751 case ACPI_NOTIFY_DEVICE_WAKE: 752 /* TBD */ 753 break; 754 755 case ACPI_NOTIFY_EJECT_REQUEST: 756 /* TBD */ 757 break; 758 759 case ACPI_NOTIFY_DEVICE_CHECK_LIGHT: 760 /* TBD: Exactly what does 'light' mean? */ 761 break; 762 763 case ACPI_NOTIFY_FREQUENCY_MISMATCH: 764 /* TBD */ 765 break; 766 767 case ACPI_NOTIFY_BUS_MODE_MISMATCH: 768 /* TBD */ 769 break; 770 771 case ACPI_NOTIFY_POWER_FAULT: 772 /* TBD */ 773 break; 774 775 default: 776 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 777 "Received unknown/unsupported notification [%08x]\n", 778 type)); 779 break; 780 } 781 782 acpi_bus_get_device(handle, &device); 783 if (device) { 784 driver = device->driver; 785 if (driver && driver->ops.notify && 786 (driver->flags & ACPI_DRIVER_ALL_NOTIFY_EVENTS)) 787 driver->ops.notify(device, type); 788 } 789 } 790 791 /* -------------------------------------------------------------------------- 792 Initialization/Cleanup 793 -------------------------------------------------------------------------- */ 794 795 static int __init acpi_bus_init_irq(void) 796 { 797 acpi_status status = AE_OK; 798 union acpi_object arg = { ACPI_TYPE_INTEGER }; 799 struct acpi_object_list arg_list = { 1, &arg }; 800 char *message = NULL; 801 802 803 /* 804 * Let the system know what interrupt model we are using by 805 * evaluating the \_PIC object, if exists. 806 */ 807 808 switch (acpi_irq_model) { 809 case ACPI_IRQ_MODEL_PIC: 810 message = "PIC"; 811 break; 812 case ACPI_IRQ_MODEL_IOAPIC: 813 message = "IOAPIC"; 814 break; 815 case ACPI_IRQ_MODEL_IOSAPIC: 816 message = "IOSAPIC"; 817 break; 818 case ACPI_IRQ_MODEL_PLATFORM: 819 message = "platform specific model"; 820 break; 821 default: 822 printk(KERN_WARNING PREFIX "Unknown interrupt routing model\n"); 823 return -ENODEV; 824 } 825 826 printk(KERN_INFO PREFIX "Using %s for interrupt routing\n", message); 827 828 arg.integer.value = acpi_irq_model; 829 830 status = acpi_evaluate_object(NULL, "\\_PIC", &arg_list, NULL); 831 if (ACPI_FAILURE(status) && (status != AE_NOT_FOUND)) { 832 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _PIC")); 833 return -ENODEV; 834 } 835 836 return 0; 837 } 838 839 u8 acpi_gbl_permanent_mmap; 840 841 842 void __init acpi_early_init(void) 843 { 844 acpi_status status = AE_OK; 845 846 if (acpi_disabled) 847 return; 848 849 printk(KERN_INFO PREFIX "Core revision %08x\n", ACPI_CA_VERSION); 850 851 /* enable workarounds, unless strict ACPI spec. compliance */ 852 if (!acpi_strict) 853 acpi_gbl_enable_interpreter_slack = TRUE; 854 855 acpi_gbl_permanent_mmap = 1; 856 857 /* 858 * If the machine falls into the DMI check table, 859 * DSDT will be copied to memory 860 */ 861 dmi_check_system(dsdt_dmi_table); 862 863 status = acpi_reallocate_root_table(); 864 if (ACPI_FAILURE(status)) { 865 printk(KERN_ERR PREFIX 866 "Unable to reallocate ACPI tables\n"); 867 goto error0; 868 } 869 870 status = acpi_initialize_subsystem(); 871 if (ACPI_FAILURE(status)) { 872 printk(KERN_ERR PREFIX 873 "Unable to initialize the ACPI Interpreter\n"); 874 goto error0; 875 } 876 877 status = acpi_load_tables(); 878 if (ACPI_FAILURE(status)) { 879 printk(KERN_ERR PREFIX 880 "Unable to load the System Description Tables\n"); 881 goto error0; 882 } 883 884 #ifdef CONFIG_X86 885 if (!acpi_ioapic) { 886 /* compatible (0) means level (3) */ 887 if (!(acpi_sci_flags & ACPI_MADT_TRIGGER_MASK)) { 888 acpi_sci_flags &= ~ACPI_MADT_TRIGGER_MASK; 889 acpi_sci_flags |= ACPI_MADT_TRIGGER_LEVEL; 890 } 891 /* Set PIC-mode SCI trigger type */ 892 acpi_pic_sci_set_trigger(acpi_gbl_FADT.sci_interrupt, 893 (acpi_sci_flags & ACPI_MADT_TRIGGER_MASK) >> 2); 894 } else { 895 /* 896 * now that acpi_gbl_FADT is initialized, 897 * update it with result from INT_SRC_OVR parsing 898 */ 899 acpi_gbl_FADT.sci_interrupt = acpi_sci_override_gsi; 900 } 901 #endif 902 903 status = 904 acpi_enable_subsystem(~ 905 (ACPI_NO_HARDWARE_INIT | 906 ACPI_NO_ACPI_ENABLE)); 907 if (ACPI_FAILURE(status)) { 908 printk(KERN_ERR PREFIX "Unable to enable ACPI\n"); 909 goto error0; 910 } 911 912 return; 913 914 error0: 915 disable_acpi(); 916 return; 917 } 918 919 static int __init acpi_bus_init(void) 920 { 921 int result = 0; 922 acpi_status status = AE_OK; 923 extern acpi_status acpi_os_initialize1(void); 924 925 acpi_os_initialize1(); 926 927 status = 928 acpi_enable_subsystem(ACPI_NO_HARDWARE_INIT | ACPI_NO_ACPI_ENABLE); 929 if (ACPI_FAILURE(status)) { 930 printk(KERN_ERR PREFIX 931 "Unable to start the ACPI Interpreter\n"); 932 goto error1; 933 } 934 935 /* 936 * ACPI 2.0 requires the EC driver to be loaded and work before 937 * the EC device is found in the namespace (i.e. before acpi_initialize_objects() 938 * is called). 939 * 940 * This is accomplished by looking for the ECDT table, and getting 941 * the EC parameters out of that. 942 */ 943 status = acpi_ec_ecdt_probe(); 944 /* Ignore result. Not having an ECDT is not fatal. */ 945 946 acpi_bus_osc_support(); 947 948 status = acpi_initialize_objects(ACPI_FULL_INITIALIZATION); 949 if (ACPI_FAILURE(status)) { 950 printk(KERN_ERR PREFIX "Unable to initialize ACPI objects\n"); 951 goto error1; 952 } 953 954 /* 955 * _PDC control method may load dynamic SSDT tables, 956 * and we need to install the table handler before that. 957 */ 958 acpi_sysfs_init(); 959 960 acpi_early_processor_set_pdc(); 961 962 /* 963 * Maybe EC region is required at bus_scan/acpi_get_devices. So it 964 * is necessary to enable it as early as possible. 965 */ 966 acpi_boot_ec_enable(); 967 968 printk(KERN_INFO PREFIX "Interpreter enabled\n"); 969 970 /* Initialize sleep structures */ 971 acpi_sleep_init(); 972 973 /* 974 * Get the system interrupt model and evaluate \_PIC. 975 */ 976 result = acpi_bus_init_irq(); 977 if (result) 978 goto error1; 979 980 /* 981 * Register the for all standard device notifications. 982 */ 983 status = 984 acpi_install_notify_handler(ACPI_ROOT_OBJECT, ACPI_SYSTEM_NOTIFY, 985 &acpi_bus_notify, NULL); 986 if (ACPI_FAILURE(status)) { 987 printk(KERN_ERR PREFIX 988 "Unable to register for device notifications\n"); 989 goto error1; 990 } 991 992 /* 993 * Create the top ACPI proc directory 994 */ 995 acpi_root_dir = proc_mkdir(ACPI_BUS_FILE_ROOT, NULL); 996 997 return 0; 998 999 /* Mimic structured exception handling */ 1000 error1: 1001 acpi_terminate(); 1002 return -ENODEV; 1003 } 1004 1005 struct kobject *acpi_kobj; 1006 1007 static int __init acpi_init(void) 1008 { 1009 int result = 0; 1010 1011 1012 if (acpi_disabled) { 1013 printk(KERN_INFO PREFIX "Interpreter disabled.\n"); 1014 return -ENODEV; 1015 } 1016 1017 acpi_kobj = kobject_create_and_add("acpi", firmware_kobj); 1018 if (!acpi_kobj) { 1019 printk(KERN_WARNING "%s: kset create error\n", __func__); 1020 acpi_kobj = NULL; 1021 } 1022 1023 init_acpi_device_notify(); 1024 result = acpi_bus_init(); 1025 1026 if (!result) { 1027 pci_mmcfg_late_init(); 1028 if (!(pm_flags & PM_APM)) 1029 pm_flags |= PM_ACPI; 1030 else { 1031 printk(KERN_INFO PREFIX 1032 "APM is already active, exiting\n"); 1033 disable_acpi(); 1034 result = -ENODEV; 1035 } 1036 } else 1037 disable_acpi(); 1038 1039 if (acpi_disabled) 1040 return result; 1041 1042 acpi_scan_init(); 1043 acpi_ec_init(); 1044 acpi_debugfs_init(); 1045 acpi_sleep_proc_init(); 1046 acpi_wakeup_device_init(); 1047 return result; 1048 } 1049 1050 subsys_initcall(acpi_init); 1051