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