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 49 ACPI_MODULE_NAME("bus"); 50 51 struct acpi_device *acpi_root; 52 struct proc_dir_entry *acpi_root_dir; 53 EXPORT_SYMBOL(acpi_root_dir); 54 55 #define STRUCT_TO_INT(s) (*((int*)&s)) 56 57 58 #ifdef CONFIG_X86 59 static 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 67 static 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 83 static struct dmi_system_id dsdt_dmi_table[] __initdata = { 84 {} 85 }; 86 #endif 87 88 /* -------------------------------------------------------------------------- 89 Device Management 90 -------------------------------------------------------------------------- */ 91 92 int acpi_bus_get_device(acpi_handle handle, struct acpi_device **device) 93 { 94 acpi_status status; 95 96 if (!device) 97 return -EINVAL; 98 99 /* TBD: Support fixed-feature devices */ 100 101 status = acpi_get_data(handle, acpi_bus_data_handler, (void **)device); 102 if (ACPI_FAILURE(status) || !*device) { 103 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No context for object [%p]\n", 104 handle)); 105 return -ENODEV; 106 } 107 108 return 0; 109 } 110 111 EXPORT_SYMBOL(acpi_bus_get_device); 112 113 acpi_status acpi_bus_get_status_handle(acpi_handle handle, 114 unsigned long long *sta) 115 { 116 acpi_status status; 117 118 status = acpi_evaluate_integer(handle, "_STA", NULL, sta); 119 if (ACPI_SUCCESS(status)) 120 return AE_OK; 121 122 if (status == AE_NOT_FOUND) { 123 *sta = ACPI_STA_DEVICE_PRESENT | ACPI_STA_DEVICE_ENABLED | 124 ACPI_STA_DEVICE_UI | ACPI_STA_DEVICE_FUNCTIONING; 125 return AE_OK; 126 } 127 return status; 128 } 129 130 int acpi_bus_get_status(struct acpi_device *device) 131 { 132 acpi_status status; 133 unsigned long long sta; 134 135 status = acpi_bus_get_status_handle(device->handle, &sta); 136 if (ACPI_FAILURE(status)) 137 return -ENODEV; 138 139 STRUCT_TO_INT(device->status) = (int) sta; 140 141 if (device->status.functional && !device->status.present) { 142 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device [%s] status [%08x]: " 143 "functional but not present;\n", 144 device->pnp.bus_id, 145 (u32) STRUCT_TO_INT(device->status))); 146 } 147 148 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device [%s] status [%08x]\n", 149 device->pnp.bus_id, 150 (u32) STRUCT_TO_INT(device->status))); 151 return 0; 152 } 153 EXPORT_SYMBOL(acpi_bus_get_status); 154 155 void acpi_bus_private_data_handler(acpi_handle handle, 156 void *context) 157 { 158 return; 159 } 160 EXPORT_SYMBOL(acpi_bus_private_data_handler); 161 162 int acpi_bus_get_private_data(acpi_handle handle, void **data) 163 { 164 acpi_status status; 165 166 if (!*data) 167 return -EINVAL; 168 169 status = acpi_get_data(handle, acpi_bus_private_data_handler, data); 170 if (ACPI_FAILURE(status) || !*data) { 171 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No context for object [%p]\n", 172 handle)); 173 return -ENODEV; 174 } 175 176 return 0; 177 } 178 EXPORT_SYMBOL(acpi_bus_get_private_data); 179 180 static void acpi_print_osc_error(acpi_handle handle, 181 struct acpi_osc_context *context, char *error) 182 { 183 struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER}; 184 int i; 185 186 if (ACPI_FAILURE(acpi_get_name(handle, ACPI_FULL_PATHNAME, &buffer))) 187 printk(KERN_DEBUG "%s\n", error); 188 else { 189 printk(KERN_DEBUG "%s:%s\n", (char *)buffer.pointer, error); 190 kfree(buffer.pointer); 191 } 192 printk(KERN_DEBUG"_OSC request data:"); 193 for (i = 0; i < context->cap.length; i += sizeof(u32)) 194 printk("%x ", *((u32 *)(context->cap.pointer + i))); 195 printk("\n"); 196 } 197 198 static acpi_status acpi_str_to_uuid(char *str, u8 *uuid) 199 { 200 int i; 201 static int opc_map_to_uuid[16] = {6, 4, 2, 0, 11, 9, 16, 14, 19, 21, 202 24, 26, 28, 30, 32, 34}; 203 204 if (strlen(str) != 36) 205 return AE_BAD_PARAMETER; 206 for (i = 0; i < 36; i++) { 207 if (i == 8 || i == 13 || i == 18 || i == 23) { 208 if (str[i] != '-') 209 return AE_BAD_PARAMETER; 210 } else if (!isxdigit(str[i])) 211 return AE_BAD_PARAMETER; 212 } 213 for (i = 0; i < 16; i++) { 214 uuid[i] = hex_to_bin(str[opc_map_to_uuid[i]]) << 4; 215 uuid[i] |= hex_to_bin(str[opc_map_to_uuid[i] + 1]); 216 } 217 return AE_OK; 218 } 219 220 acpi_status acpi_run_osc(acpi_handle handle, struct acpi_osc_context *context) 221 { 222 acpi_status status; 223 struct acpi_object_list input; 224 union acpi_object in_params[4]; 225 union acpi_object *out_obj; 226 u8 uuid[16]; 227 u32 errors; 228 struct acpi_buffer output = {ACPI_ALLOCATE_BUFFER, NULL}; 229 230 if (!context) 231 return AE_ERROR; 232 if (ACPI_FAILURE(acpi_str_to_uuid(context->uuid_str, uuid))) 233 return AE_ERROR; 234 context->ret.length = ACPI_ALLOCATE_BUFFER; 235 context->ret.pointer = NULL; 236 237 /* Setting up input parameters */ 238 input.count = 4; 239 input.pointer = in_params; 240 in_params[0].type = ACPI_TYPE_BUFFER; 241 in_params[0].buffer.length = 16; 242 in_params[0].buffer.pointer = uuid; 243 in_params[1].type = ACPI_TYPE_INTEGER; 244 in_params[1].integer.value = context->rev; 245 in_params[2].type = ACPI_TYPE_INTEGER; 246 in_params[2].integer.value = context->cap.length/sizeof(u32); 247 in_params[3].type = ACPI_TYPE_BUFFER; 248 in_params[3].buffer.length = context->cap.length; 249 in_params[3].buffer.pointer = context->cap.pointer; 250 251 status = acpi_evaluate_object(handle, "_OSC", &input, &output); 252 if (ACPI_FAILURE(status)) 253 return status; 254 255 if (!output.length) 256 return AE_NULL_OBJECT; 257 258 out_obj = output.pointer; 259 if (out_obj->type != ACPI_TYPE_BUFFER 260 || out_obj->buffer.length != context->cap.length) { 261 acpi_print_osc_error(handle, context, 262 "_OSC evaluation returned wrong type"); 263 status = AE_TYPE; 264 goto out_kfree; 265 } 266 /* Need to ignore the bit0 in result code */ 267 errors = *((u32 *)out_obj->buffer.pointer) & ~(1 << 0); 268 if (errors) { 269 if (errors & OSC_REQUEST_ERROR) 270 acpi_print_osc_error(handle, context, 271 "_OSC request failed"); 272 if (errors & OSC_INVALID_UUID_ERROR) 273 acpi_print_osc_error(handle, context, 274 "_OSC invalid UUID"); 275 if (errors & OSC_INVALID_REVISION_ERROR) 276 acpi_print_osc_error(handle, context, 277 "_OSC invalid revision"); 278 if (errors & OSC_CAPABILITIES_MASK_ERROR) { 279 if (((u32 *)context->cap.pointer)[OSC_QUERY_TYPE] 280 & OSC_QUERY_ENABLE) 281 goto out_success; 282 status = AE_SUPPORT; 283 goto out_kfree; 284 } 285 status = AE_ERROR; 286 goto out_kfree; 287 } 288 out_success: 289 context->ret.length = out_obj->buffer.length; 290 context->ret.pointer = kmemdup(out_obj->buffer.pointer, 291 context->ret.length, GFP_KERNEL); 292 if (!context->ret.pointer) { 293 status = AE_NO_MEMORY; 294 goto out_kfree; 295 } 296 status = AE_OK; 297 298 out_kfree: 299 kfree(output.pointer); 300 if (status != AE_OK) 301 context->ret.pointer = NULL; 302 return status; 303 } 304 EXPORT_SYMBOL(acpi_run_osc); 305 306 bool osc_sb_apei_support_acked; 307 static u8 sb_uuid_str[] = "0811B06E-4A27-44F9-8D60-3CBBC22E7B48"; 308 static void acpi_bus_osc_support(void) 309 { 310 u32 capbuf[2]; 311 struct acpi_osc_context context = { 312 .uuid_str = sb_uuid_str, 313 .rev = 1, 314 .cap.length = 8, 315 .cap.pointer = capbuf, 316 }; 317 acpi_handle handle; 318 319 capbuf[OSC_QUERY_TYPE] = OSC_QUERY_ENABLE; 320 capbuf[OSC_SUPPORT_TYPE] = OSC_SB_PR3_SUPPORT; /* _PR3 is in use */ 321 #if defined(CONFIG_ACPI_PROCESSOR_AGGREGATOR) ||\ 322 defined(CONFIG_ACPI_PROCESSOR_AGGREGATOR_MODULE) 323 capbuf[OSC_SUPPORT_TYPE] |= OSC_SB_PAD_SUPPORT; 324 #endif 325 326 #if defined(CONFIG_ACPI_PROCESSOR) || defined(CONFIG_ACPI_PROCESSOR_MODULE) 327 capbuf[OSC_SUPPORT_TYPE] |= OSC_SB_PPC_OST_SUPPORT; 328 #endif 329 330 #ifdef ACPI_HOTPLUG_OST 331 capbuf[OSC_SUPPORT_TYPE] |= OSC_SB_HOTPLUG_OST_SUPPORT; 332 #endif 333 334 if (!ghes_disable) 335 capbuf[OSC_SUPPORT_TYPE] |= OSC_SB_APEI_SUPPORT; 336 if (ACPI_FAILURE(acpi_get_handle(NULL, "\\_SB", &handle))) 337 return; 338 if (ACPI_SUCCESS(acpi_run_osc(handle, &context))) { 339 u32 *capbuf_ret = context.ret.pointer; 340 if (context.ret.length > OSC_SUPPORT_TYPE) 341 osc_sb_apei_support_acked = 342 capbuf_ret[OSC_SUPPORT_TYPE] & OSC_SB_APEI_SUPPORT; 343 kfree(context.ret.pointer); 344 } 345 /* do we need to check other returned cap? Sounds no */ 346 } 347 348 /* -------------------------------------------------------------------------- 349 Event Management 350 -------------------------------------------------------------------------- */ 351 352 #ifdef CONFIG_ACPI_PROC_EVENT 353 static DEFINE_SPINLOCK(acpi_bus_event_lock); 354 355 LIST_HEAD(acpi_bus_event_list); 356 DECLARE_WAIT_QUEUE_HEAD(acpi_bus_event_queue); 357 358 extern int event_is_open; 359 360 int acpi_bus_generate_proc_event4(const char *device_class, const char *bus_id, u8 type, int data) 361 { 362 struct acpi_bus_event *event; 363 unsigned long flags; 364 365 /* drop event on the floor if no one's listening */ 366 if (!event_is_open) 367 return 0; 368 369 event = kzalloc(sizeof(struct acpi_bus_event), GFP_ATOMIC); 370 if (!event) 371 return -ENOMEM; 372 373 strcpy(event->device_class, device_class); 374 strcpy(event->bus_id, bus_id); 375 event->type = type; 376 event->data = data; 377 378 spin_lock_irqsave(&acpi_bus_event_lock, flags); 379 list_add_tail(&event->node, &acpi_bus_event_list); 380 spin_unlock_irqrestore(&acpi_bus_event_lock, flags); 381 382 wake_up_interruptible(&acpi_bus_event_queue); 383 384 return 0; 385 386 } 387 388 EXPORT_SYMBOL_GPL(acpi_bus_generate_proc_event4); 389 390 int acpi_bus_generate_proc_event(struct acpi_device *device, u8 type, int data) 391 { 392 if (!device) 393 return -EINVAL; 394 return acpi_bus_generate_proc_event4(device->pnp.device_class, 395 device->pnp.bus_id, type, data); 396 } 397 398 EXPORT_SYMBOL(acpi_bus_generate_proc_event); 399 400 int acpi_bus_receive_event(struct acpi_bus_event *event) 401 { 402 unsigned long flags; 403 struct acpi_bus_event *entry = NULL; 404 405 DECLARE_WAITQUEUE(wait, current); 406 407 408 if (!event) 409 return -EINVAL; 410 411 if (list_empty(&acpi_bus_event_list)) { 412 413 set_current_state(TASK_INTERRUPTIBLE); 414 add_wait_queue(&acpi_bus_event_queue, &wait); 415 416 if (list_empty(&acpi_bus_event_list)) 417 schedule(); 418 419 remove_wait_queue(&acpi_bus_event_queue, &wait); 420 set_current_state(TASK_RUNNING); 421 422 if (signal_pending(current)) 423 return -ERESTARTSYS; 424 } 425 426 spin_lock_irqsave(&acpi_bus_event_lock, flags); 427 if (!list_empty(&acpi_bus_event_list)) { 428 entry = list_entry(acpi_bus_event_list.next, 429 struct acpi_bus_event, node); 430 list_del(&entry->node); 431 } 432 spin_unlock_irqrestore(&acpi_bus_event_lock, flags); 433 434 if (!entry) 435 return -ENODEV; 436 437 memcpy(event, entry, sizeof(struct acpi_bus_event)); 438 439 kfree(entry); 440 441 return 0; 442 } 443 444 #endif /* CONFIG_ACPI_PROC_EVENT */ 445 446 /* -------------------------------------------------------------------------- 447 Notification Handling 448 -------------------------------------------------------------------------- */ 449 450 static void acpi_bus_check_device(acpi_handle handle) 451 { 452 struct acpi_device *device; 453 acpi_status status; 454 struct acpi_device_status old_status; 455 456 if (acpi_bus_get_device(handle, &device)) 457 return; 458 if (!device) 459 return; 460 461 old_status = device->status; 462 463 /* 464 * Make sure this device's parent is present before we go about 465 * messing with the device. 466 */ 467 if (device->parent && !device->parent->status.present) { 468 device->status = device->parent->status; 469 return; 470 } 471 472 status = acpi_bus_get_status(device); 473 if (ACPI_FAILURE(status)) 474 return; 475 476 if (STRUCT_TO_INT(old_status) == STRUCT_TO_INT(device->status)) 477 return; 478 479 /* 480 * Device Insertion/Removal 481 */ 482 if ((device->status.present) && !(old_status.present)) { 483 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device insertion detected\n")); 484 /* TBD: Handle device insertion */ 485 } else if (!(device->status.present) && (old_status.present)) { 486 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device removal detected\n")); 487 /* TBD: Handle device removal */ 488 } 489 } 490 491 static void acpi_bus_check_scope(acpi_handle handle) 492 { 493 /* Status Change? */ 494 acpi_bus_check_device(handle); 495 496 /* 497 * TBD: Enumerate child devices within this device's scope and 498 * run acpi_bus_check_device()'s on them. 499 */ 500 } 501 502 static BLOCKING_NOTIFIER_HEAD(acpi_bus_notify_list); 503 int register_acpi_bus_notifier(struct notifier_block *nb) 504 { 505 return blocking_notifier_chain_register(&acpi_bus_notify_list, nb); 506 } 507 EXPORT_SYMBOL_GPL(register_acpi_bus_notifier); 508 509 void unregister_acpi_bus_notifier(struct notifier_block *nb) 510 { 511 blocking_notifier_chain_unregister(&acpi_bus_notify_list, nb); 512 } 513 EXPORT_SYMBOL_GPL(unregister_acpi_bus_notifier); 514 515 /** 516 * acpi_bus_notify 517 * --------------- 518 * Callback for all 'system-level' device notifications (values 0x00-0x7F). 519 */ 520 static void acpi_bus_notify(acpi_handle handle, u32 type, void *data) 521 { 522 struct acpi_device *device = NULL; 523 struct acpi_driver *driver; 524 525 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Notification %#02x to handle %p\n", 526 type, handle)); 527 528 blocking_notifier_call_chain(&acpi_bus_notify_list, 529 type, (void *)handle); 530 531 switch (type) { 532 533 case ACPI_NOTIFY_BUS_CHECK: 534 acpi_bus_check_scope(handle); 535 /* 536 * TBD: We'll need to outsource certain events to non-ACPI 537 * drivers via the device manager (device.c). 538 */ 539 break; 540 541 case ACPI_NOTIFY_DEVICE_CHECK: 542 acpi_bus_check_device(handle); 543 /* 544 * TBD: We'll need to outsource certain events to non-ACPI 545 * drivers via the device manager (device.c). 546 */ 547 break; 548 549 case ACPI_NOTIFY_DEVICE_WAKE: 550 /* TBD */ 551 break; 552 553 case ACPI_NOTIFY_EJECT_REQUEST: 554 /* TBD */ 555 break; 556 557 case ACPI_NOTIFY_DEVICE_CHECK_LIGHT: 558 /* TBD: Exactly what does 'light' mean? */ 559 break; 560 561 case ACPI_NOTIFY_FREQUENCY_MISMATCH: 562 /* TBD */ 563 break; 564 565 case ACPI_NOTIFY_BUS_MODE_MISMATCH: 566 /* TBD */ 567 break; 568 569 case ACPI_NOTIFY_POWER_FAULT: 570 /* TBD */ 571 break; 572 573 default: 574 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 575 "Received unknown/unsupported notification [%08x]\n", 576 type)); 577 break; 578 } 579 580 acpi_bus_get_device(handle, &device); 581 if (device) { 582 driver = device->driver; 583 if (driver && driver->ops.notify && 584 (driver->flags & ACPI_DRIVER_ALL_NOTIFY_EVENTS)) 585 driver->ops.notify(device, type); 586 } 587 } 588 589 /* -------------------------------------------------------------------------- 590 Initialization/Cleanup 591 -------------------------------------------------------------------------- */ 592 593 static int __init acpi_bus_init_irq(void) 594 { 595 acpi_status status; 596 union acpi_object arg = { ACPI_TYPE_INTEGER }; 597 struct acpi_object_list arg_list = { 1, &arg }; 598 char *message = NULL; 599 600 601 /* 602 * Let the system know what interrupt model we are using by 603 * evaluating the \_PIC object, if exists. 604 */ 605 606 switch (acpi_irq_model) { 607 case ACPI_IRQ_MODEL_PIC: 608 message = "PIC"; 609 break; 610 case ACPI_IRQ_MODEL_IOAPIC: 611 message = "IOAPIC"; 612 break; 613 case ACPI_IRQ_MODEL_IOSAPIC: 614 message = "IOSAPIC"; 615 break; 616 case ACPI_IRQ_MODEL_PLATFORM: 617 message = "platform specific model"; 618 break; 619 default: 620 printk(KERN_WARNING PREFIX "Unknown interrupt routing model\n"); 621 return -ENODEV; 622 } 623 624 printk(KERN_INFO PREFIX "Using %s for interrupt routing\n", message); 625 626 arg.integer.value = acpi_irq_model; 627 628 status = acpi_evaluate_object(NULL, "\\_PIC", &arg_list, NULL); 629 if (ACPI_FAILURE(status) && (status != AE_NOT_FOUND)) { 630 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _PIC")); 631 return -ENODEV; 632 } 633 634 return 0; 635 } 636 637 u8 acpi_gbl_permanent_mmap; 638 639 640 void __init acpi_early_init(void) 641 { 642 acpi_status status; 643 644 if (acpi_disabled) 645 return; 646 647 printk(KERN_INFO PREFIX "Core revision %08x\n", ACPI_CA_VERSION); 648 649 /* enable workarounds, unless strict ACPI spec. compliance */ 650 if (!acpi_strict) 651 acpi_gbl_enable_interpreter_slack = TRUE; 652 653 acpi_gbl_permanent_mmap = 1; 654 655 /* 656 * If the machine falls into the DMI check table, 657 * DSDT will be copied to memory 658 */ 659 dmi_check_system(dsdt_dmi_table); 660 661 status = acpi_reallocate_root_table(); 662 if (ACPI_FAILURE(status)) { 663 printk(KERN_ERR PREFIX 664 "Unable to reallocate ACPI tables\n"); 665 goto error0; 666 } 667 668 status = acpi_initialize_subsystem(); 669 if (ACPI_FAILURE(status)) { 670 printk(KERN_ERR PREFIX 671 "Unable to initialize the ACPI Interpreter\n"); 672 goto error0; 673 } 674 675 status = acpi_load_tables(); 676 if (ACPI_FAILURE(status)) { 677 printk(KERN_ERR PREFIX 678 "Unable to load the System Description Tables\n"); 679 goto error0; 680 } 681 682 #ifdef CONFIG_X86 683 if (!acpi_ioapic) { 684 /* compatible (0) means level (3) */ 685 if (!(acpi_sci_flags & ACPI_MADT_TRIGGER_MASK)) { 686 acpi_sci_flags &= ~ACPI_MADT_TRIGGER_MASK; 687 acpi_sci_flags |= ACPI_MADT_TRIGGER_LEVEL; 688 } 689 /* Set PIC-mode SCI trigger type */ 690 acpi_pic_sci_set_trigger(acpi_gbl_FADT.sci_interrupt, 691 (acpi_sci_flags & ACPI_MADT_TRIGGER_MASK) >> 2); 692 } else { 693 /* 694 * now that acpi_gbl_FADT is initialized, 695 * update it with result from INT_SRC_OVR parsing 696 */ 697 acpi_gbl_FADT.sci_interrupt = acpi_sci_override_gsi; 698 } 699 #endif 700 701 status = acpi_enable_subsystem(~ACPI_NO_ACPI_ENABLE); 702 if (ACPI_FAILURE(status)) { 703 printk(KERN_ERR PREFIX "Unable to enable ACPI\n"); 704 goto error0; 705 } 706 707 return; 708 709 error0: 710 disable_acpi(); 711 return; 712 } 713 714 static int __init acpi_bus_init(void) 715 { 716 int result; 717 acpi_status status; 718 extern acpi_status acpi_os_initialize1(void); 719 720 acpi_os_initialize1(); 721 722 status = acpi_enable_subsystem(ACPI_NO_ACPI_ENABLE); 723 if (ACPI_FAILURE(status)) { 724 printk(KERN_ERR PREFIX 725 "Unable to start the ACPI Interpreter\n"); 726 goto error1; 727 } 728 729 /* 730 * ACPI 2.0 requires the EC driver to be loaded and work before 731 * the EC device is found in the namespace (i.e. before acpi_initialize_objects() 732 * is called). 733 * 734 * This is accomplished by looking for the ECDT table, and getting 735 * the EC parameters out of that. 736 */ 737 status = acpi_ec_ecdt_probe(); 738 /* Ignore result. Not having an ECDT is not fatal. */ 739 740 status = acpi_initialize_objects(ACPI_FULL_INITIALIZATION); 741 if (ACPI_FAILURE(status)) { 742 printk(KERN_ERR PREFIX "Unable to initialize ACPI objects\n"); 743 goto error1; 744 } 745 746 /* 747 * _OSC method may exist in module level code, 748 * so it must be run after ACPI_FULL_INITIALIZATION 749 */ 750 acpi_bus_osc_support(); 751 752 /* 753 * _PDC control method may load dynamic SSDT tables, 754 * and we need to install the table handler before that. 755 */ 756 acpi_sysfs_init(); 757 758 acpi_early_processor_set_pdc(); 759 760 /* 761 * Maybe EC region is required at bus_scan/acpi_get_devices. So it 762 * is necessary to enable it as early as possible. 763 */ 764 acpi_boot_ec_enable(); 765 766 printk(KERN_INFO PREFIX "Interpreter enabled\n"); 767 768 /* Initialize sleep structures */ 769 acpi_sleep_init(); 770 771 /* 772 * Get the system interrupt model and evaluate \_PIC. 773 */ 774 result = acpi_bus_init_irq(); 775 if (result) 776 goto error1; 777 778 /* 779 * Register the for all standard device notifications. 780 */ 781 status = 782 acpi_install_notify_handler(ACPI_ROOT_OBJECT, ACPI_SYSTEM_NOTIFY, 783 &acpi_bus_notify, NULL); 784 if (ACPI_FAILURE(status)) { 785 printk(KERN_ERR PREFIX 786 "Unable to register for device notifications\n"); 787 goto error1; 788 } 789 790 /* 791 * Create the top ACPI proc directory 792 */ 793 acpi_root_dir = proc_mkdir(ACPI_BUS_FILE_ROOT, NULL); 794 795 return 0; 796 797 /* Mimic structured exception handling */ 798 error1: 799 acpi_terminate(); 800 return -ENODEV; 801 } 802 803 struct kobject *acpi_kobj; 804 EXPORT_SYMBOL_GPL(acpi_kobj); 805 806 static int __init acpi_init(void) 807 { 808 int result; 809 810 if (acpi_disabled) { 811 printk(KERN_INFO PREFIX "Interpreter disabled.\n"); 812 return -ENODEV; 813 } 814 815 acpi_kobj = kobject_create_and_add("acpi", firmware_kobj); 816 if (!acpi_kobj) { 817 printk(KERN_WARNING "%s: kset create error\n", __func__); 818 acpi_kobj = NULL; 819 } 820 821 init_acpi_device_notify(); 822 result = acpi_bus_init(); 823 if (result) { 824 disable_acpi(); 825 return result; 826 } 827 828 pci_mmcfg_late_init(); 829 acpi_scan_init(); 830 acpi_ec_init(); 831 acpi_debugfs_init(); 832 acpi_sleep_proc_init(); 833 acpi_wakeup_device_init(); 834 return 0; 835 } 836 837 subsys_initcall(acpi_init); 838