1 /* 2 * scan.c - support for transforming the ACPI namespace into individual objects 3 */ 4 5 #include <linux/module.h> 6 #include <linux/init.h> 7 #include <linux/slab.h> 8 #include <linux/kernel.h> 9 #include <linux/acpi.h> 10 #include <linux/signal.h> 11 #include <linux/kthread.h> 12 #include <linux/dmi.h> 13 #include <linux/nls.h> 14 #include <linux/dma-mapping.h> 15 16 #include <asm/pgtable.h> 17 18 #include "internal.h" 19 20 #define _COMPONENT ACPI_BUS_COMPONENT 21 ACPI_MODULE_NAME("scan"); 22 extern struct acpi_device *acpi_root; 23 24 #define ACPI_BUS_CLASS "system_bus" 25 #define ACPI_BUS_HID "LNXSYBUS" 26 #define ACPI_BUS_DEVICE_NAME "System Bus" 27 28 #define ACPI_IS_ROOT_DEVICE(device) (!(device)->parent) 29 30 #define INVALID_ACPI_HANDLE ((acpi_handle)empty_zero_page) 31 32 /* 33 * If set, devices will be hot-removed even if they cannot be put offline 34 * gracefully (from the kernel's standpoint). 35 */ 36 bool acpi_force_hot_remove; 37 38 static const char *dummy_hid = "device"; 39 40 static LIST_HEAD(acpi_dep_list); 41 static DEFINE_MUTEX(acpi_dep_list_lock); 42 LIST_HEAD(acpi_bus_id_list); 43 static DEFINE_MUTEX(acpi_scan_lock); 44 static LIST_HEAD(acpi_scan_handlers_list); 45 DEFINE_MUTEX(acpi_device_lock); 46 LIST_HEAD(acpi_wakeup_device_list); 47 static DEFINE_MUTEX(acpi_hp_context_lock); 48 49 /* 50 * The UART device described by the SPCR table is the only object which needs 51 * special-casing. Everything else is covered by ACPI namespace paths in STAO 52 * table. 53 */ 54 static u64 spcr_uart_addr; 55 56 struct acpi_dep_data { 57 struct list_head node; 58 acpi_handle master; 59 acpi_handle slave; 60 }; 61 62 void acpi_scan_lock_acquire(void) 63 { 64 mutex_lock(&acpi_scan_lock); 65 } 66 EXPORT_SYMBOL_GPL(acpi_scan_lock_acquire); 67 68 void acpi_scan_lock_release(void) 69 { 70 mutex_unlock(&acpi_scan_lock); 71 } 72 EXPORT_SYMBOL_GPL(acpi_scan_lock_release); 73 74 void acpi_lock_hp_context(void) 75 { 76 mutex_lock(&acpi_hp_context_lock); 77 } 78 79 void acpi_unlock_hp_context(void) 80 { 81 mutex_unlock(&acpi_hp_context_lock); 82 } 83 84 void acpi_initialize_hp_context(struct acpi_device *adev, 85 struct acpi_hotplug_context *hp, 86 int (*notify)(struct acpi_device *, u32), 87 void (*uevent)(struct acpi_device *, u32)) 88 { 89 acpi_lock_hp_context(); 90 hp->notify = notify; 91 hp->uevent = uevent; 92 acpi_set_hp_context(adev, hp); 93 acpi_unlock_hp_context(); 94 } 95 EXPORT_SYMBOL_GPL(acpi_initialize_hp_context); 96 97 int acpi_scan_add_handler(struct acpi_scan_handler *handler) 98 { 99 if (!handler) 100 return -EINVAL; 101 102 list_add_tail(&handler->list_node, &acpi_scan_handlers_list); 103 return 0; 104 } 105 106 int acpi_scan_add_handler_with_hotplug(struct acpi_scan_handler *handler, 107 const char *hotplug_profile_name) 108 { 109 int error; 110 111 error = acpi_scan_add_handler(handler); 112 if (error) 113 return error; 114 115 acpi_sysfs_add_hotplug_profile(&handler->hotplug, hotplug_profile_name); 116 return 0; 117 } 118 119 bool acpi_scan_is_offline(struct acpi_device *adev, bool uevent) 120 { 121 struct acpi_device_physical_node *pn; 122 bool offline = true; 123 124 /* 125 * acpi_container_offline() calls this for all of the container's 126 * children under the container's physical_node_lock lock. 127 */ 128 mutex_lock_nested(&adev->physical_node_lock, SINGLE_DEPTH_NESTING); 129 130 list_for_each_entry(pn, &adev->physical_node_list, node) 131 if (device_supports_offline(pn->dev) && !pn->dev->offline) { 132 if (uevent) 133 kobject_uevent(&pn->dev->kobj, KOBJ_CHANGE); 134 135 offline = false; 136 break; 137 } 138 139 mutex_unlock(&adev->physical_node_lock); 140 return offline; 141 } 142 143 static acpi_status acpi_bus_offline(acpi_handle handle, u32 lvl, void *data, 144 void **ret_p) 145 { 146 struct acpi_device *device = NULL; 147 struct acpi_device_physical_node *pn; 148 bool second_pass = (bool)data; 149 acpi_status status = AE_OK; 150 151 if (acpi_bus_get_device(handle, &device)) 152 return AE_OK; 153 154 if (device->handler && !device->handler->hotplug.enabled) { 155 *ret_p = &device->dev; 156 return AE_SUPPORT; 157 } 158 159 mutex_lock(&device->physical_node_lock); 160 161 list_for_each_entry(pn, &device->physical_node_list, node) { 162 int ret; 163 164 if (second_pass) { 165 /* Skip devices offlined by the first pass. */ 166 if (pn->put_online) 167 continue; 168 } else { 169 pn->put_online = false; 170 } 171 ret = device_offline(pn->dev); 172 if (acpi_force_hot_remove) 173 continue; 174 175 if (ret >= 0) { 176 pn->put_online = !ret; 177 } else { 178 *ret_p = pn->dev; 179 if (second_pass) { 180 status = AE_ERROR; 181 break; 182 } 183 } 184 } 185 186 mutex_unlock(&device->physical_node_lock); 187 188 return status; 189 } 190 191 static acpi_status acpi_bus_online(acpi_handle handle, u32 lvl, void *data, 192 void **ret_p) 193 { 194 struct acpi_device *device = NULL; 195 struct acpi_device_physical_node *pn; 196 197 if (acpi_bus_get_device(handle, &device)) 198 return AE_OK; 199 200 mutex_lock(&device->physical_node_lock); 201 202 list_for_each_entry(pn, &device->physical_node_list, node) 203 if (pn->put_online) { 204 device_online(pn->dev); 205 pn->put_online = false; 206 } 207 208 mutex_unlock(&device->physical_node_lock); 209 210 return AE_OK; 211 } 212 213 static int acpi_scan_try_to_offline(struct acpi_device *device) 214 { 215 acpi_handle handle = device->handle; 216 struct device *errdev = NULL; 217 acpi_status status; 218 219 /* 220 * Carry out two passes here and ignore errors in the first pass, 221 * because if the devices in question are memory blocks and 222 * CONFIG_MEMCG is set, one of the blocks may hold data structures 223 * that the other blocks depend on, but it is not known in advance which 224 * block holds them. 225 * 226 * If the first pass is successful, the second one isn't needed, though. 227 */ 228 status = acpi_walk_namespace(ACPI_TYPE_ANY, handle, ACPI_UINT32_MAX, 229 NULL, acpi_bus_offline, (void *)false, 230 (void **)&errdev); 231 if (status == AE_SUPPORT) { 232 dev_warn(errdev, "Offline disabled.\n"); 233 acpi_walk_namespace(ACPI_TYPE_ANY, handle, ACPI_UINT32_MAX, 234 acpi_bus_online, NULL, NULL, NULL); 235 return -EPERM; 236 } 237 acpi_bus_offline(handle, 0, (void *)false, (void **)&errdev); 238 if (errdev) { 239 errdev = NULL; 240 acpi_walk_namespace(ACPI_TYPE_ANY, handle, ACPI_UINT32_MAX, 241 NULL, acpi_bus_offline, (void *)true, 242 (void **)&errdev); 243 if (!errdev || acpi_force_hot_remove) 244 acpi_bus_offline(handle, 0, (void *)true, 245 (void **)&errdev); 246 247 if (errdev && !acpi_force_hot_remove) { 248 dev_warn(errdev, "Offline failed.\n"); 249 acpi_bus_online(handle, 0, NULL, NULL); 250 acpi_walk_namespace(ACPI_TYPE_ANY, handle, 251 ACPI_UINT32_MAX, acpi_bus_online, 252 NULL, NULL, NULL); 253 return -EBUSY; 254 } 255 } 256 return 0; 257 } 258 259 static int acpi_scan_hot_remove(struct acpi_device *device) 260 { 261 acpi_handle handle = device->handle; 262 unsigned long long sta; 263 acpi_status status; 264 265 if (device->handler && device->handler->hotplug.demand_offline 266 && !acpi_force_hot_remove) { 267 if (!acpi_scan_is_offline(device, true)) 268 return -EBUSY; 269 } else { 270 int error = acpi_scan_try_to_offline(device); 271 if (error) 272 return error; 273 } 274 275 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 276 "Hot-removing device %s...\n", dev_name(&device->dev))); 277 278 acpi_bus_trim(device); 279 280 acpi_evaluate_lck(handle, 0); 281 /* 282 * TBD: _EJD support. 283 */ 284 status = acpi_evaluate_ej0(handle); 285 if (status == AE_NOT_FOUND) 286 return -ENODEV; 287 else if (ACPI_FAILURE(status)) 288 return -EIO; 289 290 /* 291 * Verify if eject was indeed successful. If not, log an error 292 * message. No need to call _OST since _EJ0 call was made OK. 293 */ 294 status = acpi_evaluate_integer(handle, "_STA", NULL, &sta); 295 if (ACPI_FAILURE(status)) { 296 acpi_handle_warn(handle, 297 "Status check after eject failed (0x%x)\n", status); 298 } else if (sta & ACPI_STA_DEVICE_ENABLED) { 299 acpi_handle_warn(handle, 300 "Eject incomplete - status 0x%llx\n", sta); 301 } 302 303 return 0; 304 } 305 306 static int acpi_scan_device_not_present(struct acpi_device *adev) 307 { 308 if (!acpi_device_enumerated(adev)) { 309 dev_warn(&adev->dev, "Still not present\n"); 310 return -EALREADY; 311 } 312 acpi_bus_trim(adev); 313 return 0; 314 } 315 316 static int acpi_scan_device_check(struct acpi_device *adev) 317 { 318 int error; 319 320 acpi_bus_get_status(adev); 321 if (adev->status.present || adev->status.functional) { 322 /* 323 * This function is only called for device objects for which 324 * matching scan handlers exist. The only situation in which 325 * the scan handler is not attached to this device object yet 326 * is when the device has just appeared (either it wasn't 327 * present at all before or it was removed and then added 328 * again). 329 */ 330 if (adev->handler) { 331 dev_warn(&adev->dev, "Already enumerated\n"); 332 return -EALREADY; 333 } 334 error = acpi_bus_scan(adev->handle); 335 if (error) { 336 dev_warn(&adev->dev, "Namespace scan failure\n"); 337 return error; 338 } 339 if (!adev->handler) { 340 dev_warn(&adev->dev, "Enumeration failure\n"); 341 error = -ENODEV; 342 } 343 } else { 344 error = acpi_scan_device_not_present(adev); 345 } 346 return error; 347 } 348 349 static int acpi_scan_bus_check(struct acpi_device *adev) 350 { 351 struct acpi_scan_handler *handler = adev->handler; 352 struct acpi_device *child; 353 int error; 354 355 acpi_bus_get_status(adev); 356 if (!(adev->status.present || adev->status.functional)) { 357 acpi_scan_device_not_present(adev); 358 return 0; 359 } 360 if (handler && handler->hotplug.scan_dependent) 361 return handler->hotplug.scan_dependent(adev); 362 363 error = acpi_bus_scan(adev->handle); 364 if (error) { 365 dev_warn(&adev->dev, "Namespace scan failure\n"); 366 return error; 367 } 368 list_for_each_entry(child, &adev->children, node) { 369 error = acpi_scan_bus_check(child); 370 if (error) 371 return error; 372 } 373 return 0; 374 } 375 376 static int acpi_generic_hotplug_event(struct acpi_device *adev, u32 type) 377 { 378 switch (type) { 379 case ACPI_NOTIFY_BUS_CHECK: 380 return acpi_scan_bus_check(adev); 381 case ACPI_NOTIFY_DEVICE_CHECK: 382 return acpi_scan_device_check(adev); 383 case ACPI_NOTIFY_EJECT_REQUEST: 384 case ACPI_OST_EC_OSPM_EJECT: 385 if (adev->handler && !adev->handler->hotplug.enabled) { 386 dev_info(&adev->dev, "Eject disabled\n"); 387 return -EPERM; 388 } 389 acpi_evaluate_ost(adev->handle, ACPI_NOTIFY_EJECT_REQUEST, 390 ACPI_OST_SC_EJECT_IN_PROGRESS, NULL); 391 return acpi_scan_hot_remove(adev); 392 } 393 return -EINVAL; 394 } 395 396 void acpi_device_hotplug(struct acpi_device *adev, u32 src) 397 { 398 u32 ost_code = ACPI_OST_SC_NON_SPECIFIC_FAILURE; 399 int error = -ENODEV; 400 401 lock_device_hotplug(); 402 mutex_lock(&acpi_scan_lock); 403 404 /* 405 * The device object's ACPI handle cannot become invalid as long as we 406 * are holding acpi_scan_lock, but it might have become invalid before 407 * that lock was acquired. 408 */ 409 if (adev->handle == INVALID_ACPI_HANDLE) 410 goto err_out; 411 412 if (adev->flags.is_dock_station) { 413 error = dock_notify(adev, src); 414 } else if (adev->flags.hotplug_notify) { 415 error = acpi_generic_hotplug_event(adev, src); 416 if (error == -EPERM) { 417 ost_code = ACPI_OST_SC_EJECT_NOT_SUPPORTED; 418 goto err_out; 419 } 420 } else { 421 int (*notify)(struct acpi_device *, u32); 422 423 acpi_lock_hp_context(); 424 notify = adev->hp ? adev->hp->notify : NULL; 425 acpi_unlock_hp_context(); 426 /* 427 * There may be additional notify handlers for device objects 428 * without the .event() callback, so ignore them here. 429 */ 430 if (notify) 431 error = notify(adev, src); 432 else 433 goto out; 434 } 435 if (!error) 436 ost_code = ACPI_OST_SC_SUCCESS; 437 438 err_out: 439 acpi_evaluate_ost(adev->handle, src, ost_code, NULL); 440 441 out: 442 acpi_bus_put_acpi_device(adev); 443 mutex_unlock(&acpi_scan_lock); 444 unlock_device_hotplug(); 445 } 446 447 static void acpi_free_power_resources_lists(struct acpi_device *device) 448 { 449 int i; 450 451 if (device->wakeup.flags.valid) 452 acpi_power_resources_list_free(&device->wakeup.resources); 453 454 if (!device->power.flags.power_resources) 455 return; 456 457 for (i = ACPI_STATE_D0; i <= ACPI_STATE_D3_HOT; i++) { 458 struct acpi_device_power_state *ps = &device->power.states[i]; 459 acpi_power_resources_list_free(&ps->resources); 460 } 461 } 462 463 static void acpi_device_release(struct device *dev) 464 { 465 struct acpi_device *acpi_dev = to_acpi_device(dev); 466 467 acpi_free_properties(acpi_dev); 468 acpi_free_pnp_ids(&acpi_dev->pnp); 469 acpi_free_power_resources_lists(acpi_dev); 470 kfree(acpi_dev); 471 } 472 473 static void acpi_device_del(struct acpi_device *device) 474 { 475 struct acpi_device_bus_id *acpi_device_bus_id; 476 477 mutex_lock(&acpi_device_lock); 478 if (device->parent) 479 list_del(&device->node); 480 481 list_for_each_entry(acpi_device_bus_id, &acpi_bus_id_list, node) 482 if (!strcmp(acpi_device_bus_id->bus_id, 483 acpi_device_hid(device))) { 484 if (acpi_device_bus_id->instance_no > 0) 485 acpi_device_bus_id->instance_no--; 486 else { 487 list_del(&acpi_device_bus_id->node); 488 kfree(acpi_device_bus_id); 489 } 490 break; 491 } 492 493 list_del(&device->wakeup_list); 494 mutex_unlock(&acpi_device_lock); 495 496 acpi_power_add_remove_device(device, false); 497 acpi_device_remove_files(device); 498 if (device->remove) 499 device->remove(device); 500 501 device_del(&device->dev); 502 } 503 504 static BLOCKING_NOTIFIER_HEAD(acpi_reconfig_chain); 505 506 static LIST_HEAD(acpi_device_del_list); 507 static DEFINE_MUTEX(acpi_device_del_lock); 508 509 static void acpi_device_del_work_fn(struct work_struct *work_not_used) 510 { 511 for (;;) { 512 struct acpi_device *adev; 513 514 mutex_lock(&acpi_device_del_lock); 515 516 if (list_empty(&acpi_device_del_list)) { 517 mutex_unlock(&acpi_device_del_lock); 518 break; 519 } 520 adev = list_first_entry(&acpi_device_del_list, 521 struct acpi_device, del_list); 522 list_del(&adev->del_list); 523 524 mutex_unlock(&acpi_device_del_lock); 525 526 blocking_notifier_call_chain(&acpi_reconfig_chain, 527 ACPI_RECONFIG_DEVICE_REMOVE, adev); 528 529 acpi_device_del(adev); 530 /* 531 * Drop references to all power resources that might have been 532 * used by the device. 533 */ 534 acpi_power_transition(adev, ACPI_STATE_D3_COLD); 535 put_device(&adev->dev); 536 } 537 } 538 539 /** 540 * acpi_scan_drop_device - Drop an ACPI device object. 541 * @handle: Handle of an ACPI namespace node, not used. 542 * @context: Address of the ACPI device object to drop. 543 * 544 * This is invoked by acpi_ns_delete_node() during the removal of the ACPI 545 * namespace node the device object pointed to by @context is attached to. 546 * 547 * The unregistration is carried out asynchronously to avoid running 548 * acpi_device_del() under the ACPICA's namespace mutex and the list is used to 549 * ensure the correct ordering (the device objects must be unregistered in the 550 * same order in which the corresponding namespace nodes are deleted). 551 */ 552 static void acpi_scan_drop_device(acpi_handle handle, void *context) 553 { 554 static DECLARE_WORK(work, acpi_device_del_work_fn); 555 struct acpi_device *adev = context; 556 557 mutex_lock(&acpi_device_del_lock); 558 559 /* 560 * Use the ACPI hotplug workqueue which is ordered, so this work item 561 * won't run after any hotplug work items submitted subsequently. That 562 * prevents attempts to register device objects identical to those being 563 * deleted from happening concurrently (such attempts result from 564 * hotplug events handled via the ACPI hotplug workqueue). It also will 565 * run after all of the work items submitted previosuly, which helps 566 * those work items to ensure that they are not accessing stale device 567 * objects. 568 */ 569 if (list_empty(&acpi_device_del_list)) 570 acpi_queue_hotplug_work(&work); 571 572 list_add_tail(&adev->del_list, &acpi_device_del_list); 573 /* Make acpi_ns_validate_handle() return NULL for this handle. */ 574 adev->handle = INVALID_ACPI_HANDLE; 575 576 mutex_unlock(&acpi_device_del_lock); 577 } 578 579 static int acpi_get_device_data(acpi_handle handle, struct acpi_device **device, 580 void (*callback)(void *)) 581 { 582 acpi_status status; 583 584 if (!device) 585 return -EINVAL; 586 587 status = acpi_get_data_full(handle, acpi_scan_drop_device, 588 (void **)device, callback); 589 if (ACPI_FAILURE(status) || !*device) { 590 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No context for object [%p]\n", 591 handle)); 592 return -ENODEV; 593 } 594 return 0; 595 } 596 597 int acpi_bus_get_device(acpi_handle handle, struct acpi_device **device) 598 { 599 return acpi_get_device_data(handle, device, NULL); 600 } 601 EXPORT_SYMBOL(acpi_bus_get_device); 602 603 static void get_acpi_device(void *dev) 604 { 605 if (dev) 606 get_device(&((struct acpi_device *)dev)->dev); 607 } 608 609 struct acpi_device *acpi_bus_get_acpi_device(acpi_handle handle) 610 { 611 struct acpi_device *adev = NULL; 612 613 acpi_get_device_data(handle, &adev, get_acpi_device); 614 return adev; 615 } 616 617 void acpi_bus_put_acpi_device(struct acpi_device *adev) 618 { 619 put_device(&adev->dev); 620 } 621 622 int acpi_device_add(struct acpi_device *device, 623 void (*release)(struct device *)) 624 { 625 int result; 626 struct acpi_device_bus_id *acpi_device_bus_id, *new_bus_id; 627 int found = 0; 628 629 if (device->handle) { 630 acpi_status status; 631 632 status = acpi_attach_data(device->handle, acpi_scan_drop_device, 633 device); 634 if (ACPI_FAILURE(status)) { 635 acpi_handle_err(device->handle, 636 "Unable to attach device data\n"); 637 return -ENODEV; 638 } 639 } 640 641 /* 642 * Linkage 643 * ------- 644 * Link this device to its parent and siblings. 645 */ 646 INIT_LIST_HEAD(&device->children); 647 INIT_LIST_HEAD(&device->node); 648 INIT_LIST_HEAD(&device->wakeup_list); 649 INIT_LIST_HEAD(&device->physical_node_list); 650 INIT_LIST_HEAD(&device->del_list); 651 mutex_init(&device->physical_node_lock); 652 653 new_bus_id = kzalloc(sizeof(struct acpi_device_bus_id), GFP_KERNEL); 654 if (!new_bus_id) { 655 pr_err(PREFIX "Memory allocation error\n"); 656 result = -ENOMEM; 657 goto err_detach; 658 } 659 660 mutex_lock(&acpi_device_lock); 661 /* 662 * Find suitable bus_id and instance number in acpi_bus_id_list 663 * If failed, create one and link it into acpi_bus_id_list 664 */ 665 list_for_each_entry(acpi_device_bus_id, &acpi_bus_id_list, node) { 666 if (!strcmp(acpi_device_bus_id->bus_id, 667 acpi_device_hid(device))) { 668 acpi_device_bus_id->instance_no++; 669 found = 1; 670 kfree(new_bus_id); 671 break; 672 } 673 } 674 if (!found) { 675 acpi_device_bus_id = new_bus_id; 676 strcpy(acpi_device_bus_id->bus_id, acpi_device_hid(device)); 677 acpi_device_bus_id->instance_no = 0; 678 list_add_tail(&acpi_device_bus_id->node, &acpi_bus_id_list); 679 } 680 dev_set_name(&device->dev, "%s:%02x", acpi_device_bus_id->bus_id, acpi_device_bus_id->instance_no); 681 682 if (device->parent) 683 list_add_tail(&device->node, &device->parent->children); 684 685 if (device->wakeup.flags.valid) 686 list_add_tail(&device->wakeup_list, &acpi_wakeup_device_list); 687 mutex_unlock(&acpi_device_lock); 688 689 if (device->parent) 690 device->dev.parent = &device->parent->dev; 691 device->dev.bus = &acpi_bus_type; 692 device->dev.release = release; 693 result = device_add(&device->dev); 694 if (result) { 695 dev_err(&device->dev, "Error registering device\n"); 696 goto err; 697 } 698 699 result = acpi_device_setup_files(device); 700 if (result) 701 printk(KERN_ERR PREFIX "Error creating sysfs interface for device %s\n", 702 dev_name(&device->dev)); 703 704 return 0; 705 706 err: 707 mutex_lock(&acpi_device_lock); 708 if (device->parent) 709 list_del(&device->node); 710 list_del(&device->wakeup_list); 711 mutex_unlock(&acpi_device_lock); 712 713 err_detach: 714 acpi_detach_data(device->handle, acpi_scan_drop_device); 715 return result; 716 } 717 718 /* -------------------------------------------------------------------------- 719 Device Enumeration 720 -------------------------------------------------------------------------- */ 721 static struct acpi_device *acpi_bus_get_parent(acpi_handle handle) 722 { 723 struct acpi_device *device = NULL; 724 acpi_status status; 725 726 /* 727 * Fixed hardware devices do not appear in the namespace and do not 728 * have handles, but we fabricate acpi_devices for them, so we have 729 * to deal with them specially. 730 */ 731 if (!handle) 732 return acpi_root; 733 734 do { 735 status = acpi_get_parent(handle, &handle); 736 if (ACPI_FAILURE(status)) 737 return status == AE_NULL_ENTRY ? NULL : acpi_root; 738 } while (acpi_bus_get_device(handle, &device)); 739 return device; 740 } 741 742 acpi_status 743 acpi_bus_get_ejd(acpi_handle handle, acpi_handle *ejd) 744 { 745 acpi_status status; 746 acpi_handle tmp; 747 struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER, NULL}; 748 union acpi_object *obj; 749 750 status = acpi_get_handle(handle, "_EJD", &tmp); 751 if (ACPI_FAILURE(status)) 752 return status; 753 754 status = acpi_evaluate_object(handle, "_EJD", NULL, &buffer); 755 if (ACPI_SUCCESS(status)) { 756 obj = buffer.pointer; 757 status = acpi_get_handle(ACPI_ROOT_OBJECT, obj->string.pointer, 758 ejd); 759 kfree(buffer.pointer); 760 } 761 return status; 762 } 763 EXPORT_SYMBOL_GPL(acpi_bus_get_ejd); 764 765 static int acpi_bus_extract_wakeup_device_power_package(acpi_handle handle, 766 struct acpi_device_wakeup *wakeup) 767 { 768 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; 769 union acpi_object *package = NULL; 770 union acpi_object *element = NULL; 771 acpi_status status; 772 int err = -ENODATA; 773 774 if (!wakeup) 775 return -EINVAL; 776 777 INIT_LIST_HEAD(&wakeup->resources); 778 779 /* _PRW */ 780 status = acpi_evaluate_object(handle, "_PRW", NULL, &buffer); 781 if (ACPI_FAILURE(status)) { 782 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _PRW")); 783 return err; 784 } 785 786 package = (union acpi_object *)buffer.pointer; 787 788 if (!package || package->package.count < 2) 789 goto out; 790 791 element = &(package->package.elements[0]); 792 if (!element) 793 goto out; 794 795 if (element->type == ACPI_TYPE_PACKAGE) { 796 if ((element->package.count < 2) || 797 (element->package.elements[0].type != 798 ACPI_TYPE_LOCAL_REFERENCE) 799 || (element->package.elements[1].type != ACPI_TYPE_INTEGER)) 800 goto out; 801 802 wakeup->gpe_device = 803 element->package.elements[0].reference.handle; 804 wakeup->gpe_number = 805 (u32) element->package.elements[1].integer.value; 806 } else if (element->type == ACPI_TYPE_INTEGER) { 807 wakeup->gpe_device = NULL; 808 wakeup->gpe_number = element->integer.value; 809 } else { 810 goto out; 811 } 812 813 element = &(package->package.elements[1]); 814 if (element->type != ACPI_TYPE_INTEGER) 815 goto out; 816 817 wakeup->sleep_state = element->integer.value; 818 819 err = acpi_extract_power_resources(package, 2, &wakeup->resources); 820 if (err) 821 goto out; 822 823 if (!list_empty(&wakeup->resources)) { 824 int sleep_state; 825 826 err = acpi_power_wakeup_list_init(&wakeup->resources, 827 &sleep_state); 828 if (err) { 829 acpi_handle_warn(handle, "Retrieving current states " 830 "of wakeup power resources failed\n"); 831 acpi_power_resources_list_free(&wakeup->resources); 832 goto out; 833 } 834 if (sleep_state < wakeup->sleep_state) { 835 acpi_handle_warn(handle, "Overriding _PRW sleep state " 836 "(S%d) by S%d from power resources\n", 837 (int)wakeup->sleep_state, sleep_state); 838 wakeup->sleep_state = sleep_state; 839 } 840 } 841 842 out: 843 kfree(buffer.pointer); 844 return err; 845 } 846 847 static void acpi_wakeup_gpe_init(struct acpi_device *device) 848 { 849 static const struct acpi_device_id button_device_ids[] = { 850 {"PNP0C0C", 0}, 851 {"PNP0C0D", 0}, 852 {"PNP0C0E", 0}, 853 {"", 0}, 854 }; 855 struct acpi_device_wakeup *wakeup = &device->wakeup; 856 acpi_status status; 857 acpi_event_status event_status; 858 859 wakeup->flags.notifier_present = 0; 860 861 /* Power button, Lid switch always enable wakeup */ 862 if (!acpi_match_device_ids(device, button_device_ids)) { 863 wakeup->flags.run_wake = 1; 864 if (!acpi_match_device_ids(device, &button_device_ids[1])) { 865 /* Do not use Lid/sleep button for S5 wakeup */ 866 if (wakeup->sleep_state == ACPI_STATE_S5) 867 wakeup->sleep_state = ACPI_STATE_S4; 868 } 869 acpi_mark_gpe_for_wake(wakeup->gpe_device, wakeup->gpe_number); 870 device_set_wakeup_capable(&device->dev, true); 871 return; 872 } 873 874 acpi_setup_gpe_for_wake(device->handle, wakeup->gpe_device, 875 wakeup->gpe_number); 876 status = acpi_get_gpe_status(wakeup->gpe_device, wakeup->gpe_number, 877 &event_status); 878 if (ACPI_FAILURE(status)) 879 return; 880 881 wakeup->flags.run_wake = !!(event_status & ACPI_EVENT_FLAG_HAS_HANDLER); 882 } 883 884 static void acpi_bus_get_wakeup_device_flags(struct acpi_device *device) 885 { 886 int err; 887 888 /* Presence of _PRW indicates wake capable */ 889 if (!acpi_has_method(device->handle, "_PRW")) 890 return; 891 892 err = acpi_bus_extract_wakeup_device_power_package(device->handle, 893 &device->wakeup); 894 if (err) { 895 dev_err(&device->dev, "_PRW evaluation error: %d\n", err); 896 return; 897 } 898 899 device->wakeup.flags.valid = 1; 900 device->wakeup.prepare_count = 0; 901 acpi_wakeup_gpe_init(device); 902 /* Call _PSW/_DSW object to disable its ability to wake the sleeping 903 * system for the ACPI device with the _PRW object. 904 * The _PSW object is depreciated in ACPI 3.0 and is replaced by _DSW. 905 * So it is necessary to call _DSW object first. Only when it is not 906 * present will the _PSW object used. 907 */ 908 err = acpi_device_sleep_wake(device, 0, 0, 0); 909 if (err) 910 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 911 "error in _DSW or _PSW evaluation\n")); 912 } 913 914 static void acpi_bus_init_power_state(struct acpi_device *device, int state) 915 { 916 struct acpi_device_power_state *ps = &device->power.states[state]; 917 char pathname[5] = { '_', 'P', 'R', '0' + state, '\0' }; 918 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; 919 acpi_status status; 920 921 INIT_LIST_HEAD(&ps->resources); 922 923 /* Evaluate "_PRx" to get referenced power resources */ 924 status = acpi_evaluate_object(device->handle, pathname, NULL, &buffer); 925 if (ACPI_SUCCESS(status)) { 926 union acpi_object *package = buffer.pointer; 927 928 if (buffer.length && package 929 && package->type == ACPI_TYPE_PACKAGE 930 && package->package.count) { 931 int err = acpi_extract_power_resources(package, 0, 932 &ps->resources); 933 if (!err) 934 device->power.flags.power_resources = 1; 935 } 936 ACPI_FREE(buffer.pointer); 937 } 938 939 /* Evaluate "_PSx" to see if we can do explicit sets */ 940 pathname[2] = 'S'; 941 if (acpi_has_method(device->handle, pathname)) 942 ps->flags.explicit_set = 1; 943 944 /* State is valid if there are means to put the device into it. */ 945 if (!list_empty(&ps->resources) || ps->flags.explicit_set) 946 ps->flags.valid = 1; 947 948 ps->power = -1; /* Unknown - driver assigned */ 949 ps->latency = -1; /* Unknown - driver assigned */ 950 } 951 952 static void acpi_bus_get_power_flags(struct acpi_device *device) 953 { 954 u32 i; 955 956 /* Presence of _PS0|_PR0 indicates 'power manageable' */ 957 if (!acpi_has_method(device->handle, "_PS0") && 958 !acpi_has_method(device->handle, "_PR0")) 959 return; 960 961 device->flags.power_manageable = 1; 962 963 /* 964 * Power Management Flags 965 */ 966 if (acpi_has_method(device->handle, "_PSC")) 967 device->power.flags.explicit_get = 1; 968 969 if (acpi_has_method(device->handle, "_IRC")) 970 device->power.flags.inrush_current = 1; 971 972 if (acpi_has_method(device->handle, "_DSW")) 973 device->power.flags.dsw_present = 1; 974 975 /* 976 * Enumerate supported power management states 977 */ 978 for (i = ACPI_STATE_D0; i <= ACPI_STATE_D3_HOT; i++) 979 acpi_bus_init_power_state(device, i); 980 981 INIT_LIST_HEAD(&device->power.states[ACPI_STATE_D3_COLD].resources); 982 if (!list_empty(&device->power.states[ACPI_STATE_D3_HOT].resources)) 983 device->power.states[ACPI_STATE_D3_COLD].flags.valid = 1; 984 985 /* Set defaults for D0 and D3hot states (always valid) */ 986 device->power.states[ACPI_STATE_D0].flags.valid = 1; 987 device->power.states[ACPI_STATE_D0].power = 100; 988 device->power.states[ACPI_STATE_D3_HOT].flags.valid = 1; 989 990 if (acpi_bus_init_power(device)) 991 device->flags.power_manageable = 0; 992 } 993 994 static void acpi_bus_get_flags(struct acpi_device *device) 995 { 996 /* Presence of _STA indicates 'dynamic_status' */ 997 if (acpi_has_method(device->handle, "_STA")) 998 device->flags.dynamic_status = 1; 999 1000 /* Presence of _RMV indicates 'removable' */ 1001 if (acpi_has_method(device->handle, "_RMV")) 1002 device->flags.removable = 1; 1003 1004 /* Presence of _EJD|_EJ0 indicates 'ejectable' */ 1005 if (acpi_has_method(device->handle, "_EJD") || 1006 acpi_has_method(device->handle, "_EJ0")) 1007 device->flags.ejectable = 1; 1008 } 1009 1010 static void acpi_device_get_busid(struct acpi_device *device) 1011 { 1012 char bus_id[5] = { '?', 0 }; 1013 struct acpi_buffer buffer = { sizeof(bus_id), bus_id }; 1014 int i = 0; 1015 1016 /* 1017 * Bus ID 1018 * ------ 1019 * The device's Bus ID is simply the object name. 1020 * TBD: Shouldn't this value be unique (within the ACPI namespace)? 1021 */ 1022 if (ACPI_IS_ROOT_DEVICE(device)) { 1023 strcpy(device->pnp.bus_id, "ACPI"); 1024 return; 1025 } 1026 1027 switch (device->device_type) { 1028 case ACPI_BUS_TYPE_POWER_BUTTON: 1029 strcpy(device->pnp.bus_id, "PWRF"); 1030 break; 1031 case ACPI_BUS_TYPE_SLEEP_BUTTON: 1032 strcpy(device->pnp.bus_id, "SLPF"); 1033 break; 1034 default: 1035 acpi_get_name(device->handle, ACPI_SINGLE_NAME, &buffer); 1036 /* Clean up trailing underscores (if any) */ 1037 for (i = 3; i > 1; i--) { 1038 if (bus_id[i] == '_') 1039 bus_id[i] = '\0'; 1040 else 1041 break; 1042 } 1043 strcpy(device->pnp.bus_id, bus_id); 1044 break; 1045 } 1046 } 1047 1048 /* 1049 * acpi_ata_match - see if an acpi object is an ATA device 1050 * 1051 * If an acpi object has one of the ACPI ATA methods defined, 1052 * then we can safely call it an ATA device. 1053 */ 1054 bool acpi_ata_match(acpi_handle handle) 1055 { 1056 return acpi_has_method(handle, "_GTF") || 1057 acpi_has_method(handle, "_GTM") || 1058 acpi_has_method(handle, "_STM") || 1059 acpi_has_method(handle, "_SDD"); 1060 } 1061 1062 /* 1063 * acpi_bay_match - see if an acpi object is an ejectable driver bay 1064 * 1065 * If an acpi object is ejectable and has one of the ACPI ATA methods defined, 1066 * then we can safely call it an ejectable drive bay 1067 */ 1068 bool acpi_bay_match(acpi_handle handle) 1069 { 1070 acpi_handle phandle; 1071 1072 if (!acpi_has_method(handle, "_EJ0")) 1073 return false; 1074 if (acpi_ata_match(handle)) 1075 return true; 1076 if (ACPI_FAILURE(acpi_get_parent(handle, &phandle))) 1077 return false; 1078 1079 return acpi_ata_match(phandle); 1080 } 1081 1082 bool acpi_device_is_battery(struct acpi_device *adev) 1083 { 1084 struct acpi_hardware_id *hwid; 1085 1086 list_for_each_entry(hwid, &adev->pnp.ids, list) 1087 if (!strcmp("PNP0C0A", hwid->id)) 1088 return true; 1089 1090 return false; 1091 } 1092 1093 static bool is_ejectable_bay(struct acpi_device *adev) 1094 { 1095 acpi_handle handle = adev->handle; 1096 1097 if (acpi_has_method(handle, "_EJ0") && acpi_device_is_battery(adev)) 1098 return true; 1099 1100 return acpi_bay_match(handle); 1101 } 1102 1103 /* 1104 * acpi_dock_match - see if an acpi object has a _DCK method 1105 */ 1106 bool acpi_dock_match(acpi_handle handle) 1107 { 1108 return acpi_has_method(handle, "_DCK"); 1109 } 1110 1111 static acpi_status 1112 acpi_backlight_cap_match(acpi_handle handle, u32 level, void *context, 1113 void **return_value) 1114 { 1115 long *cap = context; 1116 1117 if (acpi_has_method(handle, "_BCM") && 1118 acpi_has_method(handle, "_BCL")) { 1119 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found generic backlight " 1120 "support\n")); 1121 *cap |= ACPI_VIDEO_BACKLIGHT; 1122 if (!acpi_has_method(handle, "_BQC")) 1123 printk(KERN_WARNING FW_BUG PREFIX "No _BQC method, " 1124 "cannot determine initial brightness\n"); 1125 /* We have backlight support, no need to scan further */ 1126 return AE_CTRL_TERMINATE; 1127 } 1128 return 0; 1129 } 1130 1131 /* Returns true if the ACPI object is a video device which can be 1132 * handled by video.ko. 1133 * The device will get a Linux specific CID added in scan.c to 1134 * identify the device as an ACPI graphics device 1135 * Be aware that the graphics device may not be physically present 1136 * Use acpi_video_get_capabilities() to detect general ACPI video 1137 * capabilities of present cards 1138 */ 1139 long acpi_is_video_device(acpi_handle handle) 1140 { 1141 long video_caps = 0; 1142 1143 /* Is this device able to support video switching ? */ 1144 if (acpi_has_method(handle, "_DOD") || acpi_has_method(handle, "_DOS")) 1145 video_caps |= ACPI_VIDEO_OUTPUT_SWITCHING; 1146 1147 /* Is this device able to retrieve a video ROM ? */ 1148 if (acpi_has_method(handle, "_ROM")) 1149 video_caps |= ACPI_VIDEO_ROM_AVAILABLE; 1150 1151 /* Is this device able to configure which video head to be POSTed ? */ 1152 if (acpi_has_method(handle, "_VPO") && 1153 acpi_has_method(handle, "_GPD") && 1154 acpi_has_method(handle, "_SPD")) 1155 video_caps |= ACPI_VIDEO_DEVICE_POSTING; 1156 1157 /* Only check for backlight functionality if one of the above hit. */ 1158 if (video_caps) 1159 acpi_walk_namespace(ACPI_TYPE_DEVICE, handle, 1160 ACPI_UINT32_MAX, acpi_backlight_cap_match, NULL, 1161 &video_caps, NULL); 1162 1163 return video_caps; 1164 } 1165 EXPORT_SYMBOL(acpi_is_video_device); 1166 1167 const char *acpi_device_hid(struct acpi_device *device) 1168 { 1169 struct acpi_hardware_id *hid; 1170 1171 if (list_empty(&device->pnp.ids)) 1172 return dummy_hid; 1173 1174 hid = list_first_entry(&device->pnp.ids, struct acpi_hardware_id, list); 1175 return hid->id; 1176 } 1177 EXPORT_SYMBOL(acpi_device_hid); 1178 1179 static void acpi_add_id(struct acpi_device_pnp *pnp, const char *dev_id) 1180 { 1181 struct acpi_hardware_id *id; 1182 1183 id = kmalloc(sizeof(*id), GFP_KERNEL); 1184 if (!id) 1185 return; 1186 1187 id->id = kstrdup_const(dev_id, GFP_KERNEL); 1188 if (!id->id) { 1189 kfree(id); 1190 return; 1191 } 1192 1193 list_add_tail(&id->list, &pnp->ids); 1194 pnp->type.hardware_id = 1; 1195 } 1196 1197 /* 1198 * Old IBM workstations have a DSDT bug wherein the SMBus object 1199 * lacks the SMBUS01 HID and the methods do not have the necessary "_" 1200 * prefix. Work around this. 1201 */ 1202 static bool acpi_ibm_smbus_match(acpi_handle handle) 1203 { 1204 char node_name[ACPI_PATH_SEGMENT_LENGTH]; 1205 struct acpi_buffer path = { sizeof(node_name), node_name }; 1206 1207 if (!dmi_name_in_vendors("IBM")) 1208 return false; 1209 1210 /* Look for SMBS object */ 1211 if (ACPI_FAILURE(acpi_get_name(handle, ACPI_SINGLE_NAME, &path)) || 1212 strcmp("SMBS", path.pointer)) 1213 return false; 1214 1215 /* Does it have the necessary (but misnamed) methods? */ 1216 if (acpi_has_method(handle, "SBI") && 1217 acpi_has_method(handle, "SBR") && 1218 acpi_has_method(handle, "SBW")) 1219 return true; 1220 1221 return false; 1222 } 1223 1224 static bool acpi_object_is_system_bus(acpi_handle handle) 1225 { 1226 acpi_handle tmp; 1227 1228 if (ACPI_SUCCESS(acpi_get_handle(NULL, "\\_SB", &tmp)) && 1229 tmp == handle) 1230 return true; 1231 if (ACPI_SUCCESS(acpi_get_handle(NULL, "\\_TZ", &tmp)) && 1232 tmp == handle) 1233 return true; 1234 1235 return false; 1236 } 1237 1238 static void acpi_set_pnp_ids(acpi_handle handle, struct acpi_device_pnp *pnp, 1239 int device_type) 1240 { 1241 acpi_status status; 1242 struct acpi_device_info *info; 1243 struct acpi_pnp_device_id_list *cid_list; 1244 int i; 1245 1246 switch (device_type) { 1247 case ACPI_BUS_TYPE_DEVICE: 1248 if (handle == ACPI_ROOT_OBJECT) { 1249 acpi_add_id(pnp, ACPI_SYSTEM_HID); 1250 break; 1251 } 1252 1253 status = acpi_get_object_info(handle, &info); 1254 if (ACPI_FAILURE(status)) { 1255 pr_err(PREFIX "%s: Error reading device info\n", 1256 __func__); 1257 return; 1258 } 1259 1260 if (info->valid & ACPI_VALID_HID) { 1261 acpi_add_id(pnp, info->hardware_id.string); 1262 pnp->type.platform_id = 1; 1263 } 1264 if (info->valid & ACPI_VALID_CID) { 1265 cid_list = &info->compatible_id_list; 1266 for (i = 0; i < cid_list->count; i++) 1267 acpi_add_id(pnp, cid_list->ids[i].string); 1268 } 1269 if (info->valid & ACPI_VALID_ADR) { 1270 pnp->bus_address = info->address; 1271 pnp->type.bus_address = 1; 1272 } 1273 if (info->valid & ACPI_VALID_UID) 1274 pnp->unique_id = kstrdup(info->unique_id.string, 1275 GFP_KERNEL); 1276 if (info->valid & ACPI_VALID_CLS) 1277 acpi_add_id(pnp, info->class_code.string); 1278 1279 kfree(info); 1280 1281 /* 1282 * Some devices don't reliably have _HIDs & _CIDs, so add 1283 * synthetic HIDs to make sure drivers can find them. 1284 */ 1285 if (acpi_is_video_device(handle)) 1286 acpi_add_id(pnp, ACPI_VIDEO_HID); 1287 else if (acpi_bay_match(handle)) 1288 acpi_add_id(pnp, ACPI_BAY_HID); 1289 else if (acpi_dock_match(handle)) 1290 acpi_add_id(pnp, ACPI_DOCK_HID); 1291 else if (acpi_ibm_smbus_match(handle)) 1292 acpi_add_id(pnp, ACPI_SMBUS_IBM_HID); 1293 else if (list_empty(&pnp->ids) && 1294 acpi_object_is_system_bus(handle)) { 1295 /* \_SB, \_TZ, LNXSYBUS */ 1296 acpi_add_id(pnp, ACPI_BUS_HID); 1297 strcpy(pnp->device_name, ACPI_BUS_DEVICE_NAME); 1298 strcpy(pnp->device_class, ACPI_BUS_CLASS); 1299 } 1300 1301 break; 1302 case ACPI_BUS_TYPE_POWER: 1303 acpi_add_id(pnp, ACPI_POWER_HID); 1304 break; 1305 case ACPI_BUS_TYPE_PROCESSOR: 1306 acpi_add_id(pnp, ACPI_PROCESSOR_OBJECT_HID); 1307 break; 1308 case ACPI_BUS_TYPE_THERMAL: 1309 acpi_add_id(pnp, ACPI_THERMAL_HID); 1310 break; 1311 case ACPI_BUS_TYPE_POWER_BUTTON: 1312 acpi_add_id(pnp, ACPI_BUTTON_HID_POWERF); 1313 break; 1314 case ACPI_BUS_TYPE_SLEEP_BUTTON: 1315 acpi_add_id(pnp, ACPI_BUTTON_HID_SLEEPF); 1316 break; 1317 } 1318 } 1319 1320 void acpi_free_pnp_ids(struct acpi_device_pnp *pnp) 1321 { 1322 struct acpi_hardware_id *id, *tmp; 1323 1324 list_for_each_entry_safe(id, tmp, &pnp->ids, list) { 1325 kfree_const(id->id); 1326 kfree(id); 1327 } 1328 kfree(pnp->unique_id); 1329 } 1330 1331 /** 1332 * acpi_dma_supported - Check DMA support for the specified device. 1333 * @adev: The pointer to acpi device 1334 * 1335 * Return false if DMA is not supported. Otherwise, return true 1336 */ 1337 bool acpi_dma_supported(struct acpi_device *adev) 1338 { 1339 if (!adev) 1340 return false; 1341 1342 if (adev->flags.cca_seen) 1343 return true; 1344 1345 /* 1346 * Per ACPI 6.0 sec 6.2.17, assume devices can do cache-coherent 1347 * DMA on "Intel platforms". Presumably that includes all x86 and 1348 * ia64, and other arches will set CONFIG_ACPI_CCA_REQUIRED=y. 1349 */ 1350 if (!IS_ENABLED(CONFIG_ACPI_CCA_REQUIRED)) 1351 return true; 1352 1353 return false; 1354 } 1355 1356 /** 1357 * acpi_get_dma_attr - Check the supported DMA attr for the specified device. 1358 * @adev: The pointer to acpi device 1359 * 1360 * Return enum dev_dma_attr. 1361 */ 1362 enum dev_dma_attr acpi_get_dma_attr(struct acpi_device *adev) 1363 { 1364 if (!acpi_dma_supported(adev)) 1365 return DEV_DMA_NOT_SUPPORTED; 1366 1367 if (adev->flags.coherent_dma) 1368 return DEV_DMA_COHERENT; 1369 else 1370 return DEV_DMA_NON_COHERENT; 1371 } 1372 1373 static void acpi_init_coherency(struct acpi_device *adev) 1374 { 1375 unsigned long long cca = 0; 1376 acpi_status status; 1377 struct acpi_device *parent = adev->parent; 1378 1379 if (parent && parent->flags.cca_seen) { 1380 /* 1381 * From ACPI spec, OSPM will ignore _CCA if an ancestor 1382 * already saw one. 1383 */ 1384 adev->flags.cca_seen = 1; 1385 cca = parent->flags.coherent_dma; 1386 } else { 1387 status = acpi_evaluate_integer(adev->handle, "_CCA", 1388 NULL, &cca); 1389 if (ACPI_SUCCESS(status)) 1390 adev->flags.cca_seen = 1; 1391 else if (!IS_ENABLED(CONFIG_ACPI_CCA_REQUIRED)) 1392 /* 1393 * If architecture does not specify that _CCA is 1394 * required for DMA-able devices (e.g. x86), 1395 * we default to _CCA=1. 1396 */ 1397 cca = 1; 1398 else 1399 acpi_handle_debug(adev->handle, 1400 "ACPI device is missing _CCA.\n"); 1401 } 1402 1403 adev->flags.coherent_dma = cca; 1404 } 1405 1406 void acpi_init_device_object(struct acpi_device *device, acpi_handle handle, 1407 int type, unsigned long long sta) 1408 { 1409 INIT_LIST_HEAD(&device->pnp.ids); 1410 device->device_type = type; 1411 device->handle = handle; 1412 device->parent = acpi_bus_get_parent(handle); 1413 device->fwnode.type = FWNODE_ACPI; 1414 acpi_set_device_status(device, sta); 1415 acpi_device_get_busid(device); 1416 acpi_set_pnp_ids(handle, &device->pnp, type); 1417 acpi_init_properties(device); 1418 acpi_bus_get_flags(device); 1419 device->flags.match_driver = false; 1420 device->flags.initialized = true; 1421 acpi_device_clear_enumerated(device); 1422 device_initialize(&device->dev); 1423 dev_set_uevent_suppress(&device->dev, true); 1424 acpi_init_coherency(device); 1425 } 1426 1427 void acpi_device_add_finalize(struct acpi_device *device) 1428 { 1429 dev_set_uevent_suppress(&device->dev, false); 1430 kobject_uevent(&device->dev.kobj, KOBJ_ADD); 1431 } 1432 1433 static int acpi_add_single_object(struct acpi_device **child, 1434 acpi_handle handle, int type, 1435 unsigned long long sta) 1436 { 1437 int result; 1438 struct acpi_device *device; 1439 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; 1440 1441 device = kzalloc(sizeof(struct acpi_device), GFP_KERNEL); 1442 if (!device) { 1443 printk(KERN_ERR PREFIX "Memory allocation error\n"); 1444 return -ENOMEM; 1445 } 1446 1447 acpi_init_device_object(device, handle, type, sta); 1448 acpi_bus_get_power_flags(device); 1449 acpi_bus_get_wakeup_device_flags(device); 1450 1451 result = acpi_device_add(device, acpi_device_release); 1452 if (result) { 1453 acpi_device_release(&device->dev); 1454 return result; 1455 } 1456 1457 acpi_power_add_remove_device(device, true); 1458 acpi_device_add_finalize(device); 1459 acpi_get_name(handle, ACPI_FULL_PATHNAME, &buffer); 1460 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Added %s [%s] parent %s\n", 1461 dev_name(&device->dev), (char *) buffer.pointer, 1462 device->parent ? dev_name(&device->parent->dev) : "(null)")); 1463 kfree(buffer.pointer); 1464 *child = device; 1465 return 0; 1466 } 1467 1468 static acpi_status acpi_get_resource_memory(struct acpi_resource *ares, 1469 void *context) 1470 { 1471 struct resource *res = context; 1472 1473 if (acpi_dev_resource_memory(ares, res)) 1474 return AE_CTRL_TERMINATE; 1475 1476 return AE_OK; 1477 } 1478 1479 static bool acpi_device_should_be_hidden(acpi_handle handle) 1480 { 1481 acpi_status status; 1482 struct resource res; 1483 1484 /* Check if it should ignore the UART device */ 1485 if (!(spcr_uart_addr && acpi_has_method(handle, METHOD_NAME__CRS))) 1486 return false; 1487 1488 /* 1489 * The UART device described in SPCR table is assumed to have only one 1490 * memory resource present. So we only look for the first one here. 1491 */ 1492 status = acpi_walk_resources(handle, METHOD_NAME__CRS, 1493 acpi_get_resource_memory, &res); 1494 if (ACPI_FAILURE(status) || res.start != spcr_uart_addr) 1495 return false; 1496 1497 acpi_handle_info(handle, "The UART device @%pa in SPCR table will be hidden\n", 1498 &res.start); 1499 1500 return true; 1501 } 1502 1503 static int acpi_bus_type_and_status(acpi_handle handle, int *type, 1504 unsigned long long *sta) 1505 { 1506 acpi_status status; 1507 acpi_object_type acpi_type; 1508 1509 status = acpi_get_type(handle, &acpi_type); 1510 if (ACPI_FAILURE(status)) 1511 return -ENODEV; 1512 1513 switch (acpi_type) { 1514 case ACPI_TYPE_ANY: /* for ACPI_ROOT_OBJECT */ 1515 case ACPI_TYPE_DEVICE: 1516 if (acpi_device_should_be_hidden(handle)) 1517 return -ENODEV; 1518 1519 *type = ACPI_BUS_TYPE_DEVICE; 1520 status = acpi_bus_get_status_handle(handle, sta); 1521 if (ACPI_FAILURE(status)) 1522 *sta = 0; 1523 break; 1524 case ACPI_TYPE_PROCESSOR: 1525 *type = ACPI_BUS_TYPE_PROCESSOR; 1526 status = acpi_bus_get_status_handle(handle, sta); 1527 if (ACPI_FAILURE(status)) 1528 return -ENODEV; 1529 break; 1530 case ACPI_TYPE_THERMAL: 1531 *type = ACPI_BUS_TYPE_THERMAL; 1532 *sta = ACPI_STA_DEFAULT; 1533 break; 1534 case ACPI_TYPE_POWER: 1535 *type = ACPI_BUS_TYPE_POWER; 1536 *sta = ACPI_STA_DEFAULT; 1537 break; 1538 default: 1539 return -ENODEV; 1540 } 1541 1542 return 0; 1543 } 1544 1545 bool acpi_device_is_present(struct acpi_device *adev) 1546 { 1547 if (adev->status.present || adev->status.functional) 1548 return true; 1549 1550 adev->flags.initialized = false; 1551 return false; 1552 } 1553 1554 static bool acpi_scan_handler_matching(struct acpi_scan_handler *handler, 1555 const char *idstr, 1556 const struct acpi_device_id **matchid) 1557 { 1558 const struct acpi_device_id *devid; 1559 1560 if (handler->match) 1561 return handler->match(idstr, matchid); 1562 1563 for (devid = handler->ids; devid->id[0]; devid++) 1564 if (!strcmp((char *)devid->id, idstr)) { 1565 if (matchid) 1566 *matchid = devid; 1567 1568 return true; 1569 } 1570 1571 return false; 1572 } 1573 1574 static struct acpi_scan_handler *acpi_scan_match_handler(const char *idstr, 1575 const struct acpi_device_id **matchid) 1576 { 1577 struct acpi_scan_handler *handler; 1578 1579 list_for_each_entry(handler, &acpi_scan_handlers_list, list_node) 1580 if (acpi_scan_handler_matching(handler, idstr, matchid)) 1581 return handler; 1582 1583 return NULL; 1584 } 1585 1586 void acpi_scan_hotplug_enabled(struct acpi_hotplug_profile *hotplug, bool val) 1587 { 1588 if (!!hotplug->enabled == !!val) 1589 return; 1590 1591 mutex_lock(&acpi_scan_lock); 1592 1593 hotplug->enabled = val; 1594 1595 mutex_unlock(&acpi_scan_lock); 1596 } 1597 1598 static void acpi_scan_init_hotplug(struct acpi_device *adev) 1599 { 1600 struct acpi_hardware_id *hwid; 1601 1602 if (acpi_dock_match(adev->handle) || is_ejectable_bay(adev)) { 1603 acpi_dock_add(adev); 1604 return; 1605 } 1606 list_for_each_entry(hwid, &adev->pnp.ids, list) { 1607 struct acpi_scan_handler *handler; 1608 1609 handler = acpi_scan_match_handler(hwid->id, NULL); 1610 if (handler) { 1611 adev->flags.hotplug_notify = true; 1612 break; 1613 } 1614 } 1615 } 1616 1617 static void acpi_device_dep_initialize(struct acpi_device *adev) 1618 { 1619 struct acpi_dep_data *dep; 1620 struct acpi_handle_list dep_devices; 1621 acpi_status status; 1622 int i; 1623 1624 if (!acpi_has_method(adev->handle, "_DEP")) 1625 return; 1626 1627 status = acpi_evaluate_reference(adev->handle, "_DEP", NULL, 1628 &dep_devices); 1629 if (ACPI_FAILURE(status)) { 1630 dev_dbg(&adev->dev, "Failed to evaluate _DEP.\n"); 1631 return; 1632 } 1633 1634 for (i = 0; i < dep_devices.count; i++) { 1635 struct acpi_device_info *info; 1636 int skip; 1637 1638 status = acpi_get_object_info(dep_devices.handles[i], &info); 1639 if (ACPI_FAILURE(status)) { 1640 dev_dbg(&adev->dev, "Error reading _DEP device info\n"); 1641 continue; 1642 } 1643 1644 /* 1645 * Skip the dependency of Windows System Power 1646 * Management Controller 1647 */ 1648 skip = info->valid & ACPI_VALID_HID && 1649 !strcmp(info->hardware_id.string, "INT3396"); 1650 1651 kfree(info); 1652 1653 if (skip) 1654 continue; 1655 1656 dep = kzalloc(sizeof(struct acpi_dep_data), GFP_KERNEL); 1657 if (!dep) 1658 return; 1659 1660 dep->master = dep_devices.handles[i]; 1661 dep->slave = adev->handle; 1662 adev->dep_unmet++; 1663 1664 mutex_lock(&acpi_dep_list_lock); 1665 list_add_tail(&dep->node , &acpi_dep_list); 1666 mutex_unlock(&acpi_dep_list_lock); 1667 } 1668 } 1669 1670 static acpi_status acpi_bus_check_add(acpi_handle handle, u32 lvl_not_used, 1671 void *not_used, void **return_value) 1672 { 1673 struct acpi_device *device = NULL; 1674 int type; 1675 unsigned long long sta; 1676 int result; 1677 1678 acpi_bus_get_device(handle, &device); 1679 if (device) 1680 goto out; 1681 1682 result = acpi_bus_type_and_status(handle, &type, &sta); 1683 if (result) 1684 return AE_OK; 1685 1686 if (type == ACPI_BUS_TYPE_POWER) { 1687 acpi_add_power_resource(handle); 1688 return AE_OK; 1689 } 1690 1691 acpi_add_single_object(&device, handle, type, sta); 1692 if (!device) 1693 return AE_CTRL_DEPTH; 1694 1695 acpi_scan_init_hotplug(device); 1696 acpi_device_dep_initialize(device); 1697 1698 out: 1699 if (!*return_value) 1700 *return_value = device; 1701 1702 return AE_OK; 1703 } 1704 1705 static int acpi_check_spi_i2c_slave(struct acpi_resource *ares, void *data) 1706 { 1707 bool *is_spi_i2c_slave_p = data; 1708 1709 if (ares->type != ACPI_RESOURCE_TYPE_SERIAL_BUS) 1710 return 1; 1711 1712 /* 1713 * devices that are connected to UART still need to be enumerated to 1714 * platform bus 1715 */ 1716 if (ares->data.common_serial_bus.type != ACPI_RESOURCE_SERIAL_TYPE_UART) 1717 *is_spi_i2c_slave_p = true; 1718 1719 /* no need to do more checking */ 1720 return -1; 1721 } 1722 1723 static void acpi_default_enumeration(struct acpi_device *device) 1724 { 1725 struct list_head resource_list; 1726 bool is_spi_i2c_slave = false; 1727 1728 /* 1729 * Do not enumerate SPI/I2C slaves as they will be enumerated by their 1730 * respective parents. 1731 */ 1732 INIT_LIST_HEAD(&resource_list); 1733 acpi_dev_get_resources(device, &resource_list, acpi_check_spi_i2c_slave, 1734 &is_spi_i2c_slave); 1735 acpi_dev_free_resource_list(&resource_list); 1736 if (!is_spi_i2c_slave) { 1737 acpi_create_platform_device(device); 1738 acpi_device_set_enumerated(device); 1739 } else { 1740 blocking_notifier_call_chain(&acpi_reconfig_chain, 1741 ACPI_RECONFIG_DEVICE_ADD, device); 1742 } 1743 } 1744 1745 static const struct acpi_device_id generic_device_ids[] = { 1746 {ACPI_DT_NAMESPACE_HID, }, 1747 {"", }, 1748 }; 1749 1750 static int acpi_generic_device_attach(struct acpi_device *adev, 1751 const struct acpi_device_id *not_used) 1752 { 1753 /* 1754 * Since ACPI_DT_NAMESPACE_HID is the only ID handled here, the test 1755 * below can be unconditional. 1756 */ 1757 if (adev->data.of_compatible) 1758 acpi_default_enumeration(adev); 1759 1760 return 1; 1761 } 1762 1763 static struct acpi_scan_handler generic_device_handler = { 1764 .ids = generic_device_ids, 1765 .attach = acpi_generic_device_attach, 1766 }; 1767 1768 static int acpi_scan_attach_handler(struct acpi_device *device) 1769 { 1770 struct acpi_hardware_id *hwid; 1771 int ret = 0; 1772 1773 list_for_each_entry(hwid, &device->pnp.ids, list) { 1774 const struct acpi_device_id *devid; 1775 struct acpi_scan_handler *handler; 1776 1777 handler = acpi_scan_match_handler(hwid->id, &devid); 1778 if (handler) { 1779 if (!handler->attach) { 1780 device->pnp.type.platform_id = 0; 1781 continue; 1782 } 1783 device->handler = handler; 1784 ret = handler->attach(device, devid); 1785 if (ret > 0) 1786 break; 1787 1788 device->handler = NULL; 1789 if (ret < 0) 1790 break; 1791 } 1792 } 1793 1794 return ret; 1795 } 1796 1797 static void acpi_bus_attach(struct acpi_device *device) 1798 { 1799 struct acpi_device *child; 1800 acpi_handle ejd; 1801 int ret; 1802 1803 if (ACPI_SUCCESS(acpi_bus_get_ejd(device->handle, &ejd))) 1804 register_dock_dependent_device(device, ejd); 1805 1806 acpi_bus_get_status(device); 1807 /* Skip devices that are not present. */ 1808 if (!acpi_device_is_present(device)) { 1809 acpi_device_clear_enumerated(device); 1810 device->flags.power_manageable = 0; 1811 return; 1812 } 1813 if (device->handler) 1814 goto ok; 1815 1816 if (!device->flags.initialized) { 1817 device->flags.power_manageable = 1818 device->power.states[ACPI_STATE_D0].flags.valid; 1819 if (acpi_bus_init_power(device)) 1820 device->flags.power_manageable = 0; 1821 1822 device->flags.initialized = true; 1823 } 1824 1825 ret = acpi_scan_attach_handler(device); 1826 if (ret < 0) 1827 return; 1828 1829 device->flags.match_driver = true; 1830 if (!ret) { 1831 ret = device_attach(&device->dev); 1832 if (ret < 0) 1833 return; 1834 1835 if (!ret && device->pnp.type.platform_id) 1836 acpi_default_enumeration(device); 1837 } 1838 1839 ok: 1840 list_for_each_entry(child, &device->children, node) 1841 acpi_bus_attach(child); 1842 1843 if (device->handler && device->handler->hotplug.notify_online) 1844 device->handler->hotplug.notify_online(device); 1845 } 1846 1847 void acpi_walk_dep_device_list(acpi_handle handle) 1848 { 1849 struct acpi_dep_data *dep, *tmp; 1850 struct acpi_device *adev; 1851 1852 mutex_lock(&acpi_dep_list_lock); 1853 list_for_each_entry_safe(dep, tmp, &acpi_dep_list, node) { 1854 if (dep->master == handle) { 1855 acpi_bus_get_device(dep->slave, &adev); 1856 if (!adev) 1857 continue; 1858 1859 adev->dep_unmet--; 1860 if (!adev->dep_unmet) 1861 acpi_bus_attach(adev); 1862 list_del(&dep->node); 1863 kfree(dep); 1864 } 1865 } 1866 mutex_unlock(&acpi_dep_list_lock); 1867 } 1868 EXPORT_SYMBOL_GPL(acpi_walk_dep_device_list); 1869 1870 /** 1871 * acpi_bus_scan - Add ACPI device node objects in a given namespace scope. 1872 * @handle: Root of the namespace scope to scan. 1873 * 1874 * Scan a given ACPI tree (probably recently hot-plugged) and create and add 1875 * found devices. 1876 * 1877 * If no devices were found, -ENODEV is returned, but it does not mean that 1878 * there has been a real error. There just have been no suitable ACPI objects 1879 * in the table trunk from which the kernel could create a device and add an 1880 * appropriate driver. 1881 * 1882 * Must be called under acpi_scan_lock. 1883 */ 1884 int acpi_bus_scan(acpi_handle handle) 1885 { 1886 void *device = NULL; 1887 1888 if (ACPI_SUCCESS(acpi_bus_check_add(handle, 0, NULL, &device))) 1889 acpi_walk_namespace(ACPI_TYPE_ANY, handle, ACPI_UINT32_MAX, 1890 acpi_bus_check_add, NULL, NULL, &device); 1891 1892 if (device) { 1893 acpi_bus_attach(device); 1894 return 0; 1895 } 1896 return -ENODEV; 1897 } 1898 EXPORT_SYMBOL(acpi_bus_scan); 1899 1900 /** 1901 * acpi_bus_trim - Detach scan handlers and drivers from ACPI device objects. 1902 * @adev: Root of the ACPI namespace scope to walk. 1903 * 1904 * Must be called under acpi_scan_lock. 1905 */ 1906 void acpi_bus_trim(struct acpi_device *adev) 1907 { 1908 struct acpi_scan_handler *handler = adev->handler; 1909 struct acpi_device *child; 1910 1911 list_for_each_entry_reverse(child, &adev->children, node) 1912 acpi_bus_trim(child); 1913 1914 adev->flags.match_driver = false; 1915 if (handler) { 1916 if (handler->detach) 1917 handler->detach(adev); 1918 1919 adev->handler = NULL; 1920 } else { 1921 device_release_driver(&adev->dev); 1922 } 1923 /* 1924 * Most likely, the device is going away, so put it into D3cold before 1925 * that. 1926 */ 1927 acpi_device_set_power(adev, ACPI_STATE_D3_COLD); 1928 adev->flags.initialized = false; 1929 acpi_device_clear_enumerated(adev); 1930 } 1931 EXPORT_SYMBOL_GPL(acpi_bus_trim); 1932 1933 static int acpi_bus_scan_fixed(void) 1934 { 1935 int result = 0; 1936 1937 /* 1938 * Enumerate all fixed-feature devices. 1939 */ 1940 if (!(acpi_gbl_FADT.flags & ACPI_FADT_POWER_BUTTON)) { 1941 struct acpi_device *device = NULL; 1942 1943 result = acpi_add_single_object(&device, NULL, 1944 ACPI_BUS_TYPE_POWER_BUTTON, 1945 ACPI_STA_DEFAULT); 1946 if (result) 1947 return result; 1948 1949 device->flags.match_driver = true; 1950 result = device_attach(&device->dev); 1951 if (result < 0) 1952 return result; 1953 1954 device_init_wakeup(&device->dev, true); 1955 } 1956 1957 if (!(acpi_gbl_FADT.flags & ACPI_FADT_SLEEP_BUTTON)) { 1958 struct acpi_device *device = NULL; 1959 1960 result = acpi_add_single_object(&device, NULL, 1961 ACPI_BUS_TYPE_SLEEP_BUTTON, 1962 ACPI_STA_DEFAULT); 1963 if (result) 1964 return result; 1965 1966 device->flags.match_driver = true; 1967 result = device_attach(&device->dev); 1968 } 1969 1970 return result < 0 ? result : 0; 1971 } 1972 1973 static void __init acpi_get_spcr_uart_addr(void) 1974 { 1975 acpi_status status; 1976 struct acpi_table_spcr *spcr_ptr; 1977 1978 status = acpi_get_table(ACPI_SIG_SPCR, 0, 1979 (struct acpi_table_header **)&spcr_ptr); 1980 if (ACPI_SUCCESS(status)) 1981 spcr_uart_addr = spcr_ptr->serial_port.address; 1982 else 1983 printk(KERN_WARNING PREFIX "STAO table present, but SPCR is missing\n"); 1984 } 1985 1986 static bool acpi_scan_initialized; 1987 1988 int __init acpi_scan_init(void) 1989 { 1990 int result; 1991 acpi_status status; 1992 struct acpi_table_stao *stao_ptr; 1993 1994 acpi_pci_root_init(); 1995 acpi_pci_link_init(); 1996 acpi_processor_init(); 1997 acpi_lpss_init(); 1998 acpi_apd_init(); 1999 acpi_cmos_rtc_init(); 2000 acpi_container_init(); 2001 acpi_memory_hotplug_init(); 2002 acpi_pnp_init(); 2003 acpi_int340x_thermal_init(); 2004 acpi_amba_init(); 2005 2006 acpi_scan_add_handler(&generic_device_handler); 2007 2008 /* 2009 * If there is STAO table, check whether it needs to ignore the UART 2010 * device in SPCR table. 2011 */ 2012 status = acpi_get_table(ACPI_SIG_STAO, 0, 2013 (struct acpi_table_header **)&stao_ptr); 2014 if (ACPI_SUCCESS(status)) { 2015 if (stao_ptr->header.length > sizeof(struct acpi_table_stao)) 2016 printk(KERN_INFO PREFIX "STAO Name List not yet supported."); 2017 2018 if (stao_ptr->ignore_uart) 2019 acpi_get_spcr_uart_addr(); 2020 } 2021 2022 mutex_lock(&acpi_scan_lock); 2023 /* 2024 * Enumerate devices in the ACPI namespace. 2025 */ 2026 result = acpi_bus_scan(ACPI_ROOT_OBJECT); 2027 if (result) 2028 goto out; 2029 2030 result = acpi_bus_get_device(ACPI_ROOT_OBJECT, &acpi_root); 2031 if (result) 2032 goto out; 2033 2034 /* Fixed feature devices do not exist on HW-reduced platform */ 2035 if (!acpi_gbl_reduced_hardware) { 2036 result = acpi_bus_scan_fixed(); 2037 if (result) { 2038 acpi_detach_data(acpi_root->handle, 2039 acpi_scan_drop_device); 2040 acpi_device_del(acpi_root); 2041 put_device(&acpi_root->dev); 2042 goto out; 2043 } 2044 } 2045 2046 acpi_update_all_gpes(); 2047 2048 acpi_scan_initialized = true; 2049 2050 out: 2051 mutex_unlock(&acpi_scan_lock); 2052 return result; 2053 } 2054 2055 static struct acpi_probe_entry *ape; 2056 static int acpi_probe_count; 2057 static DEFINE_MUTEX(acpi_probe_mutex); 2058 2059 static int __init acpi_match_madt(struct acpi_subtable_header *header, 2060 const unsigned long end) 2061 { 2062 if (!ape->subtable_valid || ape->subtable_valid(header, ape)) 2063 if (!ape->probe_subtbl(header, end)) 2064 acpi_probe_count++; 2065 2066 return 0; 2067 } 2068 2069 int __init __acpi_probe_device_table(struct acpi_probe_entry *ap_head, int nr) 2070 { 2071 int count = 0; 2072 2073 if (acpi_disabled) 2074 return 0; 2075 2076 mutex_lock(&acpi_probe_mutex); 2077 for (ape = ap_head; nr; ape++, nr--) { 2078 if (ACPI_COMPARE_NAME(ACPI_SIG_MADT, ape->id)) { 2079 acpi_probe_count = 0; 2080 acpi_table_parse_madt(ape->type, acpi_match_madt, 0); 2081 count += acpi_probe_count; 2082 } else { 2083 int res; 2084 res = acpi_table_parse(ape->id, ape->probe_table); 2085 if (!res) 2086 count++; 2087 } 2088 } 2089 mutex_unlock(&acpi_probe_mutex); 2090 2091 return count; 2092 } 2093 2094 struct acpi_table_events_work { 2095 struct work_struct work; 2096 void *table; 2097 u32 event; 2098 }; 2099 2100 static void acpi_table_events_fn(struct work_struct *work) 2101 { 2102 struct acpi_table_events_work *tew; 2103 2104 tew = container_of(work, struct acpi_table_events_work, work); 2105 2106 if (tew->event == ACPI_TABLE_EVENT_LOAD) { 2107 acpi_scan_lock_acquire(); 2108 acpi_bus_scan(ACPI_ROOT_OBJECT); 2109 acpi_scan_lock_release(); 2110 } 2111 2112 kfree(tew); 2113 } 2114 2115 void acpi_scan_table_handler(u32 event, void *table, void *context) 2116 { 2117 struct acpi_table_events_work *tew; 2118 2119 if (!acpi_scan_initialized) 2120 return; 2121 2122 if (event != ACPI_TABLE_EVENT_LOAD) 2123 return; 2124 2125 tew = kmalloc(sizeof(*tew), GFP_KERNEL); 2126 if (!tew) 2127 return; 2128 2129 INIT_WORK(&tew->work, acpi_table_events_fn); 2130 tew->table = table; 2131 tew->event = event; 2132 2133 schedule_work(&tew->work); 2134 } 2135 2136 int acpi_reconfig_notifier_register(struct notifier_block *nb) 2137 { 2138 return blocking_notifier_chain_register(&acpi_reconfig_chain, nb); 2139 } 2140 EXPORT_SYMBOL(acpi_reconfig_notifier_register); 2141 2142 int acpi_reconfig_notifier_unregister(struct notifier_block *nb) 2143 { 2144 return blocking_notifier_chain_unregister(&acpi_reconfig_chain, nb); 2145 } 2146 EXPORT_SYMBOL(acpi_reconfig_notifier_unregister); 2147