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