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