1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * scan.c - support for transforming the ACPI namespace into individual objects 4 */ 5 6 #define pr_fmt(fmt) "ACPI: " fmt 7 8 #include <linux/module.h> 9 #include <linux/init.h> 10 #include <linux/slab.h> 11 #include <linux/kernel.h> 12 #include <linux/acpi.h> 13 #include <linux/acpi_iort.h> 14 #include <linux/acpi_viot.h> 15 #include <linux/iommu.h> 16 #include <linux/signal.h> 17 #include <linux/kthread.h> 18 #include <linux/dmi.h> 19 #include <linux/dma-map-ops.h> 20 #include <linux/platform_data/x86/apple.h> 21 #include <linux/pgtable.h> 22 #include <linux/crc32.h> 23 #include <linux/dma-direct.h> 24 25 #include "internal.h" 26 #include "sleep.h" 27 28 #define ACPI_BUS_CLASS "system_bus" 29 #define ACPI_BUS_HID "LNXSYBUS" 30 #define ACPI_BUS_DEVICE_NAME "System Bus" 31 32 #define INVALID_ACPI_HANDLE ((acpi_handle)ZERO_PAGE(0)) 33 34 static const char *dummy_hid = "device"; 35 36 static LIST_HEAD(acpi_dep_list); 37 static DEFINE_MUTEX(acpi_dep_list_lock); 38 LIST_HEAD(acpi_bus_id_list); 39 static DEFINE_MUTEX(acpi_scan_lock); 40 static LIST_HEAD(acpi_scan_handlers_list); 41 DEFINE_MUTEX(acpi_device_lock); 42 LIST_HEAD(acpi_wakeup_device_list); 43 static DEFINE_MUTEX(acpi_hp_context_lock); 44 45 /* 46 * The UART device described by the SPCR table is the only object which needs 47 * special-casing. Everything else is covered by ACPI namespace paths in STAO 48 * table. 49 */ 50 static u64 spcr_uart_addr; 51 52 void acpi_scan_lock_acquire(void) 53 { 54 mutex_lock(&acpi_scan_lock); 55 } 56 EXPORT_SYMBOL_GPL(acpi_scan_lock_acquire); 57 58 void acpi_scan_lock_release(void) 59 { 60 mutex_unlock(&acpi_scan_lock); 61 } 62 EXPORT_SYMBOL_GPL(acpi_scan_lock_release); 63 64 void acpi_lock_hp_context(void) 65 { 66 mutex_lock(&acpi_hp_context_lock); 67 } 68 69 void acpi_unlock_hp_context(void) 70 { 71 mutex_unlock(&acpi_hp_context_lock); 72 } 73 74 void acpi_initialize_hp_context(struct acpi_device *adev, 75 struct acpi_hotplug_context *hp, 76 int (*notify)(struct acpi_device *, u32), 77 void (*uevent)(struct acpi_device *, u32)) 78 { 79 acpi_lock_hp_context(); 80 hp->notify = notify; 81 hp->uevent = uevent; 82 acpi_set_hp_context(adev, hp); 83 acpi_unlock_hp_context(); 84 } 85 EXPORT_SYMBOL_GPL(acpi_initialize_hp_context); 86 87 int acpi_scan_add_handler(struct acpi_scan_handler *handler) 88 { 89 if (!handler) 90 return -EINVAL; 91 92 list_add_tail(&handler->list_node, &acpi_scan_handlers_list); 93 return 0; 94 } 95 96 int acpi_scan_add_handler_with_hotplug(struct acpi_scan_handler *handler, 97 const char *hotplug_profile_name) 98 { 99 int error; 100 101 error = acpi_scan_add_handler(handler); 102 if (error) 103 return error; 104 105 acpi_sysfs_add_hotplug_profile(&handler->hotplug, hotplug_profile_name); 106 return 0; 107 } 108 109 bool acpi_scan_is_offline(struct acpi_device *adev, bool uevent) 110 { 111 struct acpi_device_physical_node *pn; 112 bool offline = true; 113 char *envp[] = { "EVENT=offline", NULL }; 114 115 /* 116 * acpi_container_offline() calls this for all of the container's 117 * children under the container's physical_node_lock lock. 118 */ 119 mutex_lock_nested(&adev->physical_node_lock, SINGLE_DEPTH_NESTING); 120 121 list_for_each_entry(pn, &adev->physical_node_list, node) 122 if (device_supports_offline(pn->dev) && !pn->dev->offline) { 123 if (uevent) 124 kobject_uevent_env(&pn->dev->kobj, KOBJ_CHANGE, envp); 125 126 offline = false; 127 break; 128 } 129 130 mutex_unlock(&adev->physical_node_lock); 131 return offline; 132 } 133 134 static acpi_status acpi_bus_offline(acpi_handle handle, u32 lvl, void *data, 135 void **ret_p) 136 { 137 struct acpi_device *device = acpi_fetch_acpi_dev(handle); 138 struct acpi_device_physical_node *pn; 139 bool second_pass = (bool)data; 140 acpi_status status = AE_OK; 141 142 if (!device) 143 return AE_OK; 144 145 if (device->handler && !device->handler->hotplug.enabled) { 146 *ret_p = &device->dev; 147 return AE_SUPPORT; 148 } 149 150 mutex_lock(&device->physical_node_lock); 151 152 list_for_each_entry(pn, &device->physical_node_list, node) { 153 int ret; 154 155 if (second_pass) { 156 /* Skip devices offlined by the first pass. */ 157 if (pn->put_online) 158 continue; 159 } else { 160 pn->put_online = false; 161 } 162 ret = device_offline(pn->dev); 163 if (ret >= 0) { 164 pn->put_online = !ret; 165 } else { 166 *ret_p = pn->dev; 167 if (second_pass) { 168 status = AE_ERROR; 169 break; 170 } 171 } 172 } 173 174 mutex_unlock(&device->physical_node_lock); 175 176 return status; 177 } 178 179 static acpi_status acpi_bus_online(acpi_handle handle, u32 lvl, void *data, 180 void **ret_p) 181 { 182 struct acpi_device *device = acpi_fetch_acpi_dev(handle); 183 struct acpi_device_physical_node *pn; 184 185 if (!device) 186 return AE_OK; 187 188 mutex_lock(&device->physical_node_lock); 189 190 list_for_each_entry(pn, &device->physical_node_list, node) 191 if (pn->put_online) { 192 device_online(pn->dev); 193 pn->put_online = false; 194 } 195 196 mutex_unlock(&device->physical_node_lock); 197 198 return AE_OK; 199 } 200 201 static int acpi_scan_try_to_offline(struct acpi_device *device) 202 { 203 acpi_handle handle = device->handle; 204 struct device *errdev = NULL; 205 acpi_status status; 206 207 /* 208 * Carry out two passes here and ignore errors in the first pass, 209 * because if the devices in question are memory blocks and 210 * CONFIG_MEMCG is set, one of the blocks may hold data structures 211 * that the other blocks depend on, but it is not known in advance which 212 * block holds them. 213 * 214 * If the first pass is successful, the second one isn't needed, though. 215 */ 216 status = acpi_walk_namespace(ACPI_TYPE_ANY, handle, ACPI_UINT32_MAX, 217 NULL, acpi_bus_offline, (void *)false, 218 (void **)&errdev); 219 if (status == AE_SUPPORT) { 220 dev_warn(errdev, "Offline disabled.\n"); 221 acpi_walk_namespace(ACPI_TYPE_ANY, handle, ACPI_UINT32_MAX, 222 acpi_bus_online, NULL, NULL, NULL); 223 return -EPERM; 224 } 225 acpi_bus_offline(handle, 0, (void *)false, (void **)&errdev); 226 if (errdev) { 227 errdev = NULL; 228 acpi_walk_namespace(ACPI_TYPE_ANY, handle, ACPI_UINT32_MAX, 229 NULL, acpi_bus_offline, (void *)true, 230 (void **)&errdev); 231 if (!errdev) 232 acpi_bus_offline(handle, 0, (void *)true, 233 (void **)&errdev); 234 235 if (errdev) { 236 dev_warn(errdev, "Offline failed.\n"); 237 acpi_bus_online(handle, 0, NULL, NULL); 238 acpi_walk_namespace(ACPI_TYPE_ANY, handle, 239 ACPI_UINT32_MAX, acpi_bus_online, 240 NULL, NULL, NULL); 241 return -EBUSY; 242 } 243 } 244 return 0; 245 } 246 247 static int acpi_scan_check_and_detach(struct acpi_device *adev, void *check) 248 { 249 struct acpi_scan_handler *handler = adev->handler; 250 251 acpi_dev_for_each_child_reverse(adev, acpi_scan_check_and_detach, check); 252 253 if (check) { 254 acpi_bus_get_status(adev); 255 /* 256 * Skip devices that are still there and take the enabled 257 * flag into account. 258 */ 259 if (acpi_device_is_enabled(adev)) 260 return 0; 261 262 /* Skip device that have not been enumerated. */ 263 if (!acpi_device_enumerated(adev)) { 264 dev_dbg(&adev->dev, "Still not enumerated\n"); 265 return 0; 266 } 267 } 268 269 adev->flags.match_driver = false; 270 if (handler) { 271 if (handler->detach) 272 handler->detach(adev); 273 274 adev->handler = NULL; 275 } else { 276 device_release_driver(&adev->dev); 277 } 278 /* 279 * Most likely, the device is going away, so put it into D3cold before 280 * that. 281 */ 282 acpi_device_set_power(adev, ACPI_STATE_D3_COLD); 283 adev->flags.initialized = false; 284 acpi_device_clear_enumerated(adev); 285 286 return 0; 287 } 288 289 static void acpi_scan_check_subtree(struct acpi_device *adev) 290 { 291 acpi_scan_check_and_detach(adev, (void *)true); 292 } 293 294 static int acpi_scan_hot_remove(struct acpi_device *device) 295 { 296 acpi_handle handle = device->handle; 297 unsigned long long sta; 298 acpi_status status; 299 300 if (device->handler && device->handler->hotplug.demand_offline) { 301 if (!acpi_scan_is_offline(device, true)) 302 return -EBUSY; 303 } else { 304 int error = acpi_scan_try_to_offline(device); 305 if (error) 306 return error; 307 } 308 309 acpi_handle_debug(handle, "Ejecting\n"); 310 311 acpi_bus_trim(device); 312 313 acpi_evaluate_lck(handle, 0); 314 /* 315 * TBD: _EJD support. 316 */ 317 status = acpi_evaluate_ej0(handle); 318 if (status == AE_NOT_FOUND) 319 return -ENODEV; 320 else if (ACPI_FAILURE(status)) 321 return -EIO; 322 323 /* 324 * Verify if eject was indeed successful. If not, log an error 325 * message. No need to call _OST since _EJ0 call was made OK. 326 */ 327 status = acpi_evaluate_integer(handle, "_STA", NULL, &sta); 328 if (ACPI_FAILURE(status)) { 329 acpi_handle_warn(handle, 330 "Status check after eject failed (0x%x)\n", status); 331 } else if (sta & ACPI_STA_DEVICE_ENABLED) { 332 acpi_handle_warn(handle, 333 "Eject incomplete - status 0x%llx\n", sta); 334 } 335 336 return 0; 337 } 338 339 static int acpi_scan_rescan_bus(struct acpi_device *adev) 340 { 341 struct acpi_scan_handler *handler = adev->handler; 342 int ret; 343 344 if (handler && handler->hotplug.scan_dependent) 345 ret = handler->hotplug.scan_dependent(adev); 346 else 347 ret = acpi_bus_scan(adev->handle); 348 349 if (ret) 350 dev_info(&adev->dev, "Namespace scan failure\n"); 351 352 return ret; 353 } 354 355 static int acpi_scan_device_check(struct acpi_device *adev) 356 { 357 struct acpi_device *parent; 358 359 acpi_scan_check_subtree(adev); 360 361 if (!acpi_device_is_present(adev)) 362 return 0; 363 364 /* 365 * This function is only called for device objects for which matching 366 * scan handlers exist. The only situation in which the scan handler 367 * is not attached to this device object yet is when the device has 368 * just appeared (either it wasn't present at all before or it was 369 * removed and then added again). 370 */ 371 if (adev->handler) { 372 dev_dbg(&adev->dev, "Already enumerated\n"); 373 return 0; 374 } 375 376 parent = acpi_dev_parent(adev); 377 if (!parent) 378 parent = adev; 379 380 return acpi_scan_rescan_bus(parent); 381 } 382 383 static int acpi_scan_bus_check(struct acpi_device *adev) 384 { 385 acpi_scan_check_subtree(adev); 386 387 return acpi_scan_rescan_bus(adev); 388 } 389 390 static int acpi_generic_hotplug_event(struct acpi_device *adev, u32 type) 391 { 392 switch (type) { 393 case ACPI_NOTIFY_BUS_CHECK: 394 return acpi_scan_bus_check(adev); 395 case ACPI_NOTIFY_DEVICE_CHECK: 396 return acpi_scan_device_check(adev); 397 case ACPI_NOTIFY_EJECT_REQUEST: 398 case ACPI_OST_EC_OSPM_EJECT: 399 if (adev->handler && !adev->handler->hotplug.enabled) { 400 dev_info(&adev->dev, "Eject disabled\n"); 401 return -EPERM; 402 } 403 acpi_evaluate_ost(adev->handle, ACPI_NOTIFY_EJECT_REQUEST, 404 ACPI_OST_SC_EJECT_IN_PROGRESS, NULL); 405 return acpi_scan_hot_remove(adev); 406 } 407 return -EINVAL; 408 } 409 410 void acpi_device_hotplug(struct acpi_device *adev, u32 src) 411 { 412 u32 ost_code = ACPI_OST_SC_NON_SPECIFIC_FAILURE; 413 int error = -ENODEV; 414 415 lock_device_hotplug(); 416 mutex_lock(&acpi_scan_lock); 417 418 /* 419 * The device object's ACPI handle cannot become invalid as long as we 420 * are holding acpi_scan_lock, but it might have become invalid before 421 * that lock was acquired. 422 */ 423 if (adev->handle == INVALID_ACPI_HANDLE) 424 goto err_out; 425 426 if (adev->flags.is_dock_station) { 427 error = dock_notify(adev, src); 428 } else if (adev->flags.hotplug_notify) { 429 error = acpi_generic_hotplug_event(adev, src); 430 } else { 431 int (*notify)(struct acpi_device *, u32); 432 433 acpi_lock_hp_context(); 434 notify = adev->hp ? adev->hp->notify : NULL; 435 acpi_unlock_hp_context(); 436 /* 437 * There may be additional notify handlers for device objects 438 * without the .event() callback, so ignore them here. 439 */ 440 if (notify) 441 error = notify(adev, src); 442 else 443 goto out; 444 } 445 switch (error) { 446 case 0: 447 ost_code = ACPI_OST_SC_SUCCESS; 448 break; 449 case -EPERM: 450 ost_code = ACPI_OST_SC_EJECT_NOT_SUPPORTED; 451 break; 452 case -EBUSY: 453 ost_code = ACPI_OST_SC_DEVICE_BUSY; 454 break; 455 default: 456 ost_code = ACPI_OST_SC_NON_SPECIFIC_FAILURE; 457 break; 458 } 459 460 err_out: 461 acpi_evaluate_ost(adev->handle, src, ost_code, NULL); 462 463 out: 464 acpi_put_acpi_dev(adev); 465 mutex_unlock(&acpi_scan_lock); 466 unlock_device_hotplug(); 467 } 468 469 static void acpi_free_power_resources_lists(struct acpi_device *device) 470 { 471 int i; 472 473 if (device->wakeup.flags.valid) 474 acpi_power_resources_list_free(&device->wakeup.resources); 475 476 if (!device->power.flags.power_resources) 477 return; 478 479 for (i = ACPI_STATE_D0; i <= ACPI_STATE_D3_HOT; i++) { 480 struct acpi_device_power_state *ps = &device->power.states[i]; 481 acpi_power_resources_list_free(&ps->resources); 482 } 483 } 484 485 static void acpi_device_release(struct device *dev) 486 { 487 struct acpi_device *acpi_dev = to_acpi_device(dev); 488 489 acpi_free_properties(acpi_dev); 490 acpi_free_pnp_ids(&acpi_dev->pnp); 491 acpi_free_power_resources_lists(acpi_dev); 492 kfree(acpi_dev); 493 } 494 495 static void acpi_device_del(struct acpi_device *device) 496 { 497 struct acpi_device_bus_id *acpi_device_bus_id; 498 499 mutex_lock(&acpi_device_lock); 500 501 list_for_each_entry(acpi_device_bus_id, &acpi_bus_id_list, node) 502 if (!strcmp(acpi_device_bus_id->bus_id, 503 acpi_device_hid(device))) { 504 ida_free(&acpi_device_bus_id->instance_ida, 505 device->pnp.instance_no); 506 if (ida_is_empty(&acpi_device_bus_id->instance_ida)) { 507 list_del(&acpi_device_bus_id->node); 508 kfree_const(acpi_device_bus_id->bus_id); 509 kfree(acpi_device_bus_id); 510 } 511 break; 512 } 513 514 list_del(&device->wakeup_list); 515 516 mutex_unlock(&acpi_device_lock); 517 518 acpi_power_add_remove_device(device, false); 519 acpi_device_remove_files(device); 520 if (device->remove) 521 device->remove(device); 522 523 device_del(&device->dev); 524 } 525 526 static BLOCKING_NOTIFIER_HEAD(acpi_reconfig_chain); 527 528 static LIST_HEAD(acpi_device_del_list); 529 static DEFINE_MUTEX(acpi_device_del_lock); 530 531 static void acpi_device_del_work_fn(struct work_struct *work_not_used) 532 { 533 for (;;) { 534 struct acpi_device *adev; 535 536 mutex_lock(&acpi_device_del_lock); 537 538 if (list_empty(&acpi_device_del_list)) { 539 mutex_unlock(&acpi_device_del_lock); 540 break; 541 } 542 adev = list_first_entry(&acpi_device_del_list, 543 struct acpi_device, del_list); 544 list_del(&adev->del_list); 545 546 mutex_unlock(&acpi_device_del_lock); 547 548 blocking_notifier_call_chain(&acpi_reconfig_chain, 549 ACPI_RECONFIG_DEVICE_REMOVE, adev); 550 551 acpi_device_del(adev); 552 /* 553 * Drop references to all power resources that might have been 554 * used by the device. 555 */ 556 acpi_power_transition(adev, ACPI_STATE_D3_COLD); 557 acpi_dev_put(adev); 558 } 559 } 560 561 /** 562 * acpi_scan_drop_device - Drop an ACPI device object. 563 * @handle: Handle of an ACPI namespace node, not used. 564 * @context: Address of the ACPI device object to drop. 565 * 566 * This is invoked by acpi_ns_delete_node() during the removal of the ACPI 567 * namespace node the device object pointed to by @context is attached to. 568 * 569 * The unregistration is carried out asynchronously to avoid running 570 * acpi_device_del() under the ACPICA's namespace mutex and the list is used to 571 * ensure the correct ordering (the device objects must be unregistered in the 572 * same order in which the corresponding namespace nodes are deleted). 573 */ 574 static void acpi_scan_drop_device(acpi_handle handle, void *context) 575 { 576 static DECLARE_WORK(work, acpi_device_del_work_fn); 577 struct acpi_device *adev = context; 578 579 mutex_lock(&acpi_device_del_lock); 580 581 /* 582 * Use the ACPI hotplug workqueue which is ordered, so this work item 583 * won't run after any hotplug work items submitted subsequently. That 584 * prevents attempts to register device objects identical to those being 585 * deleted from happening concurrently (such attempts result from 586 * hotplug events handled via the ACPI hotplug workqueue). It also will 587 * run after all of the work items submitted previously, which helps 588 * those work items to ensure that they are not accessing stale device 589 * objects. 590 */ 591 if (list_empty(&acpi_device_del_list)) 592 acpi_queue_hotplug_work(&work); 593 594 list_add_tail(&adev->del_list, &acpi_device_del_list); 595 /* Make acpi_ns_validate_handle() return NULL for this handle. */ 596 adev->handle = INVALID_ACPI_HANDLE; 597 598 mutex_unlock(&acpi_device_del_lock); 599 } 600 601 static struct acpi_device *handle_to_device(acpi_handle handle, 602 void (*callback)(void *)) 603 { 604 struct acpi_device *adev = NULL; 605 acpi_status status; 606 607 status = acpi_get_data_full(handle, acpi_scan_drop_device, 608 (void **)&adev, callback); 609 if (ACPI_FAILURE(status) || !adev) { 610 acpi_handle_debug(handle, "No context!\n"); 611 return NULL; 612 } 613 return adev; 614 } 615 616 /** 617 * acpi_fetch_acpi_dev - Retrieve ACPI device object. 618 * @handle: ACPI handle associated with the requested ACPI device object. 619 * 620 * Return a pointer to the ACPI device object associated with @handle, if 621 * present, or NULL otherwise. 622 */ 623 struct acpi_device *acpi_fetch_acpi_dev(acpi_handle handle) 624 { 625 return handle_to_device(handle, NULL); 626 } 627 EXPORT_SYMBOL_GPL(acpi_fetch_acpi_dev); 628 629 static void get_acpi_device(void *dev) 630 { 631 acpi_dev_get(dev); 632 } 633 634 /** 635 * acpi_get_acpi_dev - Retrieve ACPI device object and reference count it. 636 * @handle: ACPI handle associated with the requested ACPI device object. 637 * 638 * Return a pointer to the ACPI device object associated with @handle and bump 639 * up that object's reference counter (under the ACPI Namespace lock), if 640 * present, or return NULL otherwise. 641 * 642 * The ACPI device object reference acquired by this function needs to be 643 * dropped via acpi_dev_put(). 644 */ 645 struct acpi_device *acpi_get_acpi_dev(acpi_handle handle) 646 { 647 return handle_to_device(handle, get_acpi_device); 648 } 649 EXPORT_SYMBOL_GPL(acpi_get_acpi_dev); 650 651 static struct acpi_device_bus_id *acpi_device_bus_id_match(const char *dev_id) 652 { 653 struct acpi_device_bus_id *acpi_device_bus_id; 654 655 /* Find suitable bus_id and instance number in acpi_bus_id_list. */ 656 list_for_each_entry(acpi_device_bus_id, &acpi_bus_id_list, node) { 657 if (!strcmp(acpi_device_bus_id->bus_id, dev_id)) 658 return acpi_device_bus_id; 659 } 660 return NULL; 661 } 662 663 static int acpi_device_set_name(struct acpi_device *device, 664 struct acpi_device_bus_id *acpi_device_bus_id) 665 { 666 struct ida *instance_ida = &acpi_device_bus_id->instance_ida; 667 int result; 668 669 result = ida_alloc(instance_ida, GFP_KERNEL); 670 if (result < 0) 671 return result; 672 673 device->pnp.instance_no = result; 674 dev_set_name(&device->dev, "%s:%02x", acpi_device_bus_id->bus_id, result); 675 return 0; 676 } 677 678 int acpi_tie_acpi_dev(struct acpi_device *adev) 679 { 680 acpi_handle handle = adev->handle; 681 acpi_status status; 682 683 if (!handle) 684 return 0; 685 686 status = acpi_attach_data(handle, acpi_scan_drop_device, adev); 687 if (ACPI_FAILURE(status)) { 688 acpi_handle_err(handle, "Unable to attach device data\n"); 689 return -ENODEV; 690 } 691 692 return 0; 693 } 694 695 static void acpi_store_pld_crc(struct acpi_device *adev) 696 { 697 struct acpi_pld_info *pld; 698 acpi_status status; 699 700 status = acpi_get_physical_device_location(adev->handle, &pld); 701 if (ACPI_FAILURE(status)) 702 return; 703 704 adev->pld_crc = crc32(~0, pld, sizeof(*pld)); 705 ACPI_FREE(pld); 706 } 707 708 int acpi_device_add(struct acpi_device *device) 709 { 710 struct acpi_device_bus_id *acpi_device_bus_id; 711 int result; 712 713 /* 714 * Linkage 715 * ------- 716 * Link this device to its parent and siblings. 717 */ 718 INIT_LIST_HEAD(&device->wakeup_list); 719 INIT_LIST_HEAD(&device->physical_node_list); 720 INIT_LIST_HEAD(&device->del_list); 721 mutex_init(&device->physical_node_lock); 722 723 mutex_lock(&acpi_device_lock); 724 725 acpi_device_bus_id = acpi_device_bus_id_match(acpi_device_hid(device)); 726 if (acpi_device_bus_id) { 727 result = acpi_device_set_name(device, acpi_device_bus_id); 728 if (result) 729 goto err_unlock; 730 } else { 731 acpi_device_bus_id = kzalloc(sizeof(*acpi_device_bus_id), 732 GFP_KERNEL); 733 if (!acpi_device_bus_id) { 734 result = -ENOMEM; 735 goto err_unlock; 736 } 737 acpi_device_bus_id->bus_id = 738 kstrdup_const(acpi_device_hid(device), GFP_KERNEL); 739 if (!acpi_device_bus_id->bus_id) { 740 kfree(acpi_device_bus_id); 741 result = -ENOMEM; 742 goto err_unlock; 743 } 744 745 ida_init(&acpi_device_bus_id->instance_ida); 746 747 result = acpi_device_set_name(device, acpi_device_bus_id); 748 if (result) { 749 kfree_const(acpi_device_bus_id->bus_id); 750 kfree(acpi_device_bus_id); 751 goto err_unlock; 752 } 753 754 list_add_tail(&acpi_device_bus_id->node, &acpi_bus_id_list); 755 } 756 757 if (device->wakeup.flags.valid) 758 list_add_tail(&device->wakeup_list, &acpi_wakeup_device_list); 759 760 acpi_store_pld_crc(device); 761 762 mutex_unlock(&acpi_device_lock); 763 764 result = device_add(&device->dev); 765 if (result) { 766 dev_err(&device->dev, "Error registering device\n"); 767 goto err; 768 } 769 770 result = acpi_device_setup_files(device); 771 if (result) 772 pr_err("Error creating sysfs interface for device %s\n", 773 dev_name(&device->dev)); 774 775 return 0; 776 777 err: 778 mutex_lock(&acpi_device_lock); 779 780 list_del(&device->wakeup_list); 781 782 err_unlock: 783 mutex_unlock(&acpi_device_lock); 784 785 acpi_detach_data(device->handle, acpi_scan_drop_device); 786 787 return result; 788 } 789 790 /* -------------------------------------------------------------------------- 791 Device Enumeration 792 -------------------------------------------------------------------------- */ 793 static bool acpi_info_matches_ids(struct acpi_device_info *info, 794 const char * const ids[]) 795 { 796 struct acpi_pnp_device_id_list *cid_list = NULL; 797 int i, index; 798 799 if (!(info->valid & ACPI_VALID_HID)) 800 return false; 801 802 index = match_string(ids, -1, info->hardware_id.string); 803 if (index >= 0) 804 return true; 805 806 if (info->valid & ACPI_VALID_CID) 807 cid_list = &info->compatible_id_list; 808 809 if (!cid_list) 810 return false; 811 812 for (i = 0; i < cid_list->count; i++) { 813 index = match_string(ids, -1, cid_list->ids[i].string); 814 if (index >= 0) 815 return true; 816 } 817 818 return false; 819 } 820 821 /* List of HIDs for which we ignore matching ACPI devices, when checking _DEP lists. */ 822 static const char * const acpi_ignore_dep_ids[] = { 823 "PNP0D80", /* Windows-compatible System Power Management Controller */ 824 "INT33BD", /* Intel Baytrail Mailbox Device */ 825 "LATT2021", /* Lattice FW Update Client Driver */ 826 NULL 827 }; 828 829 /* List of HIDs for which we honor deps of matching ACPI devs, when checking _DEP lists. */ 830 static const char * const acpi_honor_dep_ids[] = { 831 "INT3472", /* Camera sensor PMIC / clk and regulator info */ 832 "INTC1059", /* IVSC (TGL) driver must be loaded to allow i2c access to camera sensors */ 833 "INTC1095", /* IVSC (ADL) driver must be loaded to allow i2c access to camera sensors */ 834 "INTC100A", /* IVSC (RPL) driver must be loaded to allow i2c access to camera sensors */ 835 "INTC10CF", /* IVSC (MTL) driver must be loaded to allow i2c access to camera sensors */ 836 NULL 837 }; 838 839 static struct acpi_device *acpi_find_parent_acpi_dev(acpi_handle handle) 840 { 841 struct acpi_device *adev; 842 843 /* 844 * Fixed hardware devices do not appear in the namespace and do not 845 * have handles, but we fabricate acpi_devices for them, so we have 846 * to deal with them specially. 847 */ 848 if (!handle) 849 return acpi_root; 850 851 do { 852 acpi_status status; 853 854 status = acpi_get_parent(handle, &handle); 855 if (ACPI_FAILURE(status)) { 856 if (status != AE_NULL_ENTRY) 857 return acpi_root; 858 859 return NULL; 860 } 861 adev = acpi_fetch_acpi_dev(handle); 862 } while (!adev); 863 return adev; 864 } 865 866 acpi_status 867 acpi_bus_get_ejd(acpi_handle handle, acpi_handle *ejd) 868 { 869 acpi_status status; 870 acpi_handle tmp; 871 struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER, NULL}; 872 union acpi_object *obj; 873 874 status = acpi_get_handle(handle, "_EJD", &tmp); 875 if (ACPI_FAILURE(status)) 876 return status; 877 878 status = acpi_evaluate_object(handle, "_EJD", NULL, &buffer); 879 if (ACPI_SUCCESS(status)) { 880 obj = buffer.pointer; 881 status = acpi_get_handle(ACPI_ROOT_OBJECT, obj->string.pointer, 882 ejd); 883 kfree(buffer.pointer); 884 } 885 return status; 886 } 887 EXPORT_SYMBOL_GPL(acpi_bus_get_ejd); 888 889 static int acpi_bus_extract_wakeup_device_power_package(struct acpi_device *dev) 890 { 891 acpi_handle handle = dev->handle; 892 struct acpi_device_wakeup *wakeup = &dev->wakeup; 893 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; 894 union acpi_object *package = NULL; 895 union acpi_object *element = NULL; 896 acpi_status status; 897 int err = -ENODATA; 898 899 INIT_LIST_HEAD(&wakeup->resources); 900 901 /* _PRW */ 902 status = acpi_evaluate_object(handle, "_PRW", NULL, &buffer); 903 if (ACPI_FAILURE(status)) { 904 acpi_handle_info(handle, "_PRW evaluation failed: %s\n", 905 acpi_format_exception(status)); 906 return err; 907 } 908 909 package = (union acpi_object *)buffer.pointer; 910 911 if (!package || package->package.count < 2) 912 goto out; 913 914 element = &(package->package.elements[0]); 915 if (!element) 916 goto out; 917 918 if (element->type == ACPI_TYPE_PACKAGE) { 919 if ((element->package.count < 2) || 920 (element->package.elements[0].type != 921 ACPI_TYPE_LOCAL_REFERENCE) 922 || (element->package.elements[1].type != ACPI_TYPE_INTEGER)) 923 goto out; 924 925 wakeup->gpe_device = 926 element->package.elements[0].reference.handle; 927 wakeup->gpe_number = 928 (u32) element->package.elements[1].integer.value; 929 } else if (element->type == ACPI_TYPE_INTEGER) { 930 wakeup->gpe_device = NULL; 931 wakeup->gpe_number = element->integer.value; 932 } else { 933 goto out; 934 } 935 936 element = &(package->package.elements[1]); 937 if (element->type != ACPI_TYPE_INTEGER) 938 goto out; 939 940 wakeup->sleep_state = element->integer.value; 941 942 err = acpi_extract_power_resources(package, 2, &wakeup->resources); 943 if (err) 944 goto out; 945 946 if (!list_empty(&wakeup->resources)) { 947 int sleep_state; 948 949 err = acpi_power_wakeup_list_init(&wakeup->resources, 950 &sleep_state); 951 if (err) { 952 acpi_handle_warn(handle, "Retrieving current states " 953 "of wakeup power resources failed\n"); 954 acpi_power_resources_list_free(&wakeup->resources); 955 goto out; 956 } 957 if (sleep_state < wakeup->sleep_state) { 958 acpi_handle_warn(handle, "Overriding _PRW sleep state " 959 "(S%d) by S%d from power resources\n", 960 (int)wakeup->sleep_state, sleep_state); 961 wakeup->sleep_state = sleep_state; 962 } 963 } 964 965 out: 966 kfree(buffer.pointer); 967 return err; 968 } 969 970 /* Do not use a button for S5 wakeup */ 971 #define ACPI_AVOID_WAKE_FROM_S5 BIT(0) 972 973 static bool acpi_wakeup_gpe_init(struct acpi_device *device) 974 { 975 static const struct acpi_device_id button_device_ids[] = { 976 {"PNP0C0C", 0}, /* Power button */ 977 {"PNP0C0D", ACPI_AVOID_WAKE_FROM_S5}, /* Lid */ 978 {"PNP0C0E", ACPI_AVOID_WAKE_FROM_S5}, /* Sleep button */ 979 {"", 0}, 980 }; 981 struct acpi_device_wakeup *wakeup = &device->wakeup; 982 const struct acpi_device_id *match; 983 acpi_status status; 984 985 wakeup->flags.notifier_present = 0; 986 987 /* Power button, Lid switch always enable wakeup */ 988 match = acpi_match_acpi_device(button_device_ids, device); 989 if (match) { 990 if ((match->driver_data & ACPI_AVOID_WAKE_FROM_S5) && 991 wakeup->sleep_state == ACPI_STATE_S5) 992 wakeup->sleep_state = ACPI_STATE_S4; 993 acpi_mark_gpe_for_wake(wakeup->gpe_device, wakeup->gpe_number); 994 device_set_wakeup_capable(&device->dev, true); 995 return true; 996 } 997 998 status = acpi_setup_gpe_for_wake(device->handle, wakeup->gpe_device, 999 wakeup->gpe_number); 1000 return ACPI_SUCCESS(status); 1001 } 1002 1003 static void acpi_bus_get_wakeup_device_flags(struct acpi_device *device) 1004 { 1005 int err; 1006 1007 /* Presence of _PRW indicates wake capable */ 1008 if (!acpi_has_method(device->handle, "_PRW")) 1009 return; 1010 1011 err = acpi_bus_extract_wakeup_device_power_package(device); 1012 if (err) { 1013 dev_err(&device->dev, "Unable to extract wakeup power resources"); 1014 return; 1015 } 1016 1017 device->wakeup.flags.valid = acpi_wakeup_gpe_init(device); 1018 device->wakeup.prepare_count = 0; 1019 /* 1020 * Call _PSW/_DSW object to disable its ability to wake the sleeping 1021 * system for the ACPI device with the _PRW object. 1022 * The _PSW object is deprecated in ACPI 3.0 and is replaced by _DSW. 1023 * So it is necessary to call _DSW object first. Only when it is not 1024 * present will the _PSW object used. 1025 */ 1026 err = acpi_device_sleep_wake(device, 0, 0, 0); 1027 if (err) 1028 pr_debug("error in _DSW or _PSW evaluation\n"); 1029 } 1030 1031 static void acpi_bus_init_power_state(struct acpi_device *device, int state) 1032 { 1033 struct acpi_device_power_state *ps = &device->power.states[state]; 1034 char pathname[5] = { '_', 'P', 'R', '0' + state, '\0' }; 1035 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; 1036 acpi_status status; 1037 1038 INIT_LIST_HEAD(&ps->resources); 1039 1040 /* Evaluate "_PRx" to get referenced power resources */ 1041 status = acpi_evaluate_object(device->handle, pathname, NULL, &buffer); 1042 if (ACPI_SUCCESS(status)) { 1043 union acpi_object *package = buffer.pointer; 1044 1045 if (buffer.length && package 1046 && package->type == ACPI_TYPE_PACKAGE 1047 && package->package.count) 1048 acpi_extract_power_resources(package, 0, &ps->resources); 1049 1050 ACPI_FREE(buffer.pointer); 1051 } 1052 1053 /* Evaluate "_PSx" to see if we can do explicit sets */ 1054 pathname[2] = 'S'; 1055 if (acpi_has_method(device->handle, pathname)) 1056 ps->flags.explicit_set = 1; 1057 1058 /* State is valid if there are means to put the device into it. */ 1059 if (!list_empty(&ps->resources) || ps->flags.explicit_set) 1060 ps->flags.valid = 1; 1061 1062 ps->power = -1; /* Unknown - driver assigned */ 1063 ps->latency = -1; /* Unknown - driver assigned */ 1064 } 1065 1066 static void acpi_bus_get_power_flags(struct acpi_device *device) 1067 { 1068 unsigned long long dsc = ACPI_STATE_D0; 1069 u32 i; 1070 1071 /* Presence of _PS0|_PR0 indicates 'power manageable' */ 1072 if (!acpi_has_method(device->handle, "_PS0") && 1073 !acpi_has_method(device->handle, "_PR0")) 1074 return; 1075 1076 device->flags.power_manageable = 1; 1077 1078 /* 1079 * Power Management Flags 1080 */ 1081 if (acpi_has_method(device->handle, "_PSC")) 1082 device->power.flags.explicit_get = 1; 1083 1084 if (acpi_has_method(device->handle, "_IRC")) 1085 device->power.flags.inrush_current = 1; 1086 1087 if (acpi_has_method(device->handle, "_DSW")) 1088 device->power.flags.dsw_present = 1; 1089 1090 acpi_evaluate_integer(device->handle, "_DSC", NULL, &dsc); 1091 device->power.state_for_enumeration = dsc; 1092 1093 /* 1094 * Enumerate supported power management states 1095 */ 1096 for (i = ACPI_STATE_D0; i <= ACPI_STATE_D3_HOT; i++) 1097 acpi_bus_init_power_state(device, i); 1098 1099 INIT_LIST_HEAD(&device->power.states[ACPI_STATE_D3_COLD].resources); 1100 1101 /* Set the defaults for D0 and D3hot (always supported). */ 1102 device->power.states[ACPI_STATE_D0].flags.valid = 1; 1103 device->power.states[ACPI_STATE_D0].power = 100; 1104 device->power.states[ACPI_STATE_D3_HOT].flags.valid = 1; 1105 1106 /* 1107 * Use power resources only if the D0 list of them is populated, because 1108 * some platforms may provide _PR3 only to indicate D3cold support and 1109 * in those cases the power resources list returned by it may be bogus. 1110 */ 1111 if (!list_empty(&device->power.states[ACPI_STATE_D0].resources)) { 1112 device->power.flags.power_resources = 1; 1113 /* 1114 * D3cold is supported if the D3hot list of power resources is 1115 * not empty. 1116 */ 1117 if (!list_empty(&device->power.states[ACPI_STATE_D3_HOT].resources)) 1118 device->power.states[ACPI_STATE_D3_COLD].flags.valid = 1; 1119 } 1120 1121 if (acpi_bus_init_power(device)) 1122 device->flags.power_manageable = 0; 1123 } 1124 1125 static void acpi_bus_get_flags(struct acpi_device *device) 1126 { 1127 /* Presence of _STA indicates 'dynamic_status' */ 1128 if (acpi_has_method(device->handle, "_STA")) 1129 device->flags.dynamic_status = 1; 1130 1131 /* Presence of _RMV indicates 'removable' */ 1132 if (acpi_has_method(device->handle, "_RMV")) 1133 device->flags.removable = 1; 1134 1135 /* Presence of _EJD|_EJ0 indicates 'ejectable' */ 1136 if (acpi_has_method(device->handle, "_EJD") || 1137 acpi_has_method(device->handle, "_EJ0")) 1138 device->flags.ejectable = 1; 1139 } 1140 1141 static void acpi_device_get_busid(struct acpi_device *device) 1142 { 1143 char bus_id[5] = { '?', 0 }; 1144 struct acpi_buffer buffer = { sizeof(bus_id), bus_id }; 1145 int i = 0; 1146 1147 /* 1148 * Bus ID 1149 * ------ 1150 * The device's Bus ID is simply the object name. 1151 * TBD: Shouldn't this value be unique (within the ACPI namespace)? 1152 */ 1153 if (!acpi_dev_parent(device)) { 1154 strcpy(device->pnp.bus_id, "ACPI"); 1155 return; 1156 } 1157 1158 switch (device->device_type) { 1159 case ACPI_BUS_TYPE_POWER_BUTTON: 1160 strcpy(device->pnp.bus_id, "PWRF"); 1161 break; 1162 case ACPI_BUS_TYPE_SLEEP_BUTTON: 1163 strcpy(device->pnp.bus_id, "SLPF"); 1164 break; 1165 case ACPI_BUS_TYPE_ECDT_EC: 1166 strcpy(device->pnp.bus_id, "ECDT"); 1167 break; 1168 default: 1169 acpi_get_name(device->handle, ACPI_SINGLE_NAME, &buffer); 1170 /* Clean up trailing underscores (if any) */ 1171 for (i = 3; i > 1; i--) { 1172 if (bus_id[i] == '_') 1173 bus_id[i] = '\0'; 1174 else 1175 break; 1176 } 1177 strcpy(device->pnp.bus_id, bus_id); 1178 break; 1179 } 1180 } 1181 1182 /* 1183 * acpi_ata_match - see if an acpi object is an ATA device 1184 * 1185 * If an acpi object has one of the ACPI ATA methods defined, 1186 * then we can safely call it an ATA device. 1187 */ 1188 bool acpi_ata_match(acpi_handle handle) 1189 { 1190 return acpi_has_method(handle, "_GTF") || 1191 acpi_has_method(handle, "_GTM") || 1192 acpi_has_method(handle, "_STM") || 1193 acpi_has_method(handle, "_SDD"); 1194 } 1195 1196 /* 1197 * acpi_bay_match - see if an acpi object is an ejectable driver bay 1198 * 1199 * If an acpi object is ejectable and has one of the ACPI ATA methods defined, 1200 * then we can safely call it an ejectable drive bay 1201 */ 1202 bool acpi_bay_match(acpi_handle handle) 1203 { 1204 acpi_handle phandle; 1205 1206 if (!acpi_has_method(handle, "_EJ0")) 1207 return false; 1208 if (acpi_ata_match(handle)) 1209 return true; 1210 if (ACPI_FAILURE(acpi_get_parent(handle, &phandle))) 1211 return false; 1212 1213 return acpi_ata_match(phandle); 1214 } 1215 1216 bool acpi_device_is_battery(struct acpi_device *adev) 1217 { 1218 struct acpi_hardware_id *hwid; 1219 1220 list_for_each_entry(hwid, &adev->pnp.ids, list) 1221 if (!strcmp("PNP0C0A", hwid->id)) 1222 return true; 1223 1224 return false; 1225 } 1226 1227 static bool is_ejectable_bay(struct acpi_device *adev) 1228 { 1229 acpi_handle handle = adev->handle; 1230 1231 if (acpi_has_method(handle, "_EJ0") && acpi_device_is_battery(adev)) 1232 return true; 1233 1234 return acpi_bay_match(handle); 1235 } 1236 1237 /* 1238 * acpi_dock_match - see if an acpi object has a _DCK method 1239 */ 1240 bool acpi_dock_match(acpi_handle handle) 1241 { 1242 return acpi_has_method(handle, "_DCK"); 1243 } 1244 1245 static acpi_status 1246 acpi_backlight_cap_match(acpi_handle handle, u32 level, void *context, 1247 void **return_value) 1248 { 1249 long *cap = context; 1250 1251 if (acpi_has_method(handle, "_BCM") && 1252 acpi_has_method(handle, "_BCL")) { 1253 acpi_handle_debug(handle, "Found generic backlight support\n"); 1254 *cap |= ACPI_VIDEO_BACKLIGHT; 1255 /* We have backlight support, no need to scan further */ 1256 return AE_CTRL_TERMINATE; 1257 } 1258 return 0; 1259 } 1260 1261 /* Returns true if the ACPI object is a video device which can be 1262 * handled by video.ko. 1263 * The device will get a Linux specific CID added in scan.c to 1264 * identify the device as an ACPI graphics device 1265 * Be aware that the graphics device may not be physically present 1266 * Use acpi_video_get_capabilities() to detect general ACPI video 1267 * capabilities of present cards 1268 */ 1269 long acpi_is_video_device(acpi_handle handle) 1270 { 1271 long video_caps = 0; 1272 1273 /* Is this device able to support video switching ? */ 1274 if (acpi_has_method(handle, "_DOD") || acpi_has_method(handle, "_DOS")) 1275 video_caps |= ACPI_VIDEO_OUTPUT_SWITCHING; 1276 1277 /* Is this device able to retrieve a video ROM ? */ 1278 if (acpi_has_method(handle, "_ROM")) 1279 video_caps |= ACPI_VIDEO_ROM_AVAILABLE; 1280 1281 /* Is this device able to configure which video head to be POSTed ? */ 1282 if (acpi_has_method(handle, "_VPO") && 1283 acpi_has_method(handle, "_GPD") && 1284 acpi_has_method(handle, "_SPD")) 1285 video_caps |= ACPI_VIDEO_DEVICE_POSTING; 1286 1287 /* Only check for backlight functionality if one of the above hit. */ 1288 if (video_caps) 1289 acpi_walk_namespace(ACPI_TYPE_DEVICE, handle, 1290 ACPI_UINT32_MAX, acpi_backlight_cap_match, NULL, 1291 &video_caps, NULL); 1292 1293 return video_caps; 1294 } 1295 EXPORT_SYMBOL(acpi_is_video_device); 1296 1297 const char *acpi_device_hid(struct acpi_device *device) 1298 { 1299 struct acpi_hardware_id *hid; 1300 1301 if (list_empty(&device->pnp.ids)) 1302 return dummy_hid; 1303 1304 hid = list_first_entry(&device->pnp.ids, struct acpi_hardware_id, list); 1305 return hid->id; 1306 } 1307 EXPORT_SYMBOL(acpi_device_hid); 1308 1309 static void acpi_add_id(struct acpi_device_pnp *pnp, const char *dev_id) 1310 { 1311 struct acpi_hardware_id *id; 1312 1313 id = kmalloc(sizeof(*id), GFP_KERNEL); 1314 if (!id) 1315 return; 1316 1317 id->id = kstrdup_const(dev_id, GFP_KERNEL); 1318 if (!id->id) { 1319 kfree(id); 1320 return; 1321 } 1322 1323 list_add_tail(&id->list, &pnp->ids); 1324 pnp->type.hardware_id = 1; 1325 } 1326 1327 /* 1328 * Old IBM workstations have a DSDT bug wherein the SMBus object 1329 * lacks the SMBUS01 HID and the methods do not have the necessary "_" 1330 * prefix. Work around this. 1331 */ 1332 static bool acpi_ibm_smbus_match(acpi_handle handle) 1333 { 1334 char node_name[ACPI_PATH_SEGMENT_LENGTH]; 1335 struct acpi_buffer path = { sizeof(node_name), node_name }; 1336 1337 if (!dmi_name_in_vendors("IBM")) 1338 return false; 1339 1340 /* Look for SMBS object */ 1341 if (ACPI_FAILURE(acpi_get_name(handle, ACPI_SINGLE_NAME, &path)) || 1342 strcmp("SMBS", path.pointer)) 1343 return false; 1344 1345 /* Does it have the necessary (but misnamed) methods? */ 1346 if (acpi_has_method(handle, "SBI") && 1347 acpi_has_method(handle, "SBR") && 1348 acpi_has_method(handle, "SBW")) 1349 return true; 1350 1351 return false; 1352 } 1353 1354 static bool acpi_object_is_system_bus(acpi_handle handle) 1355 { 1356 acpi_handle tmp; 1357 1358 if (ACPI_SUCCESS(acpi_get_handle(NULL, "\\_SB", &tmp)) && 1359 tmp == handle) 1360 return true; 1361 if (ACPI_SUCCESS(acpi_get_handle(NULL, "\\_TZ", &tmp)) && 1362 tmp == handle) 1363 return true; 1364 1365 return false; 1366 } 1367 1368 static void acpi_set_pnp_ids(acpi_handle handle, struct acpi_device_pnp *pnp, 1369 int device_type) 1370 { 1371 struct acpi_device_info *info = NULL; 1372 struct acpi_pnp_device_id_list *cid_list; 1373 int i; 1374 1375 switch (device_type) { 1376 case ACPI_BUS_TYPE_DEVICE: 1377 if (handle == ACPI_ROOT_OBJECT) { 1378 acpi_add_id(pnp, ACPI_SYSTEM_HID); 1379 break; 1380 } 1381 1382 acpi_get_object_info(handle, &info); 1383 if (!info) { 1384 pr_err("%s: Error reading device info\n", __func__); 1385 return; 1386 } 1387 1388 if (info->valid & ACPI_VALID_HID) { 1389 acpi_add_id(pnp, info->hardware_id.string); 1390 pnp->type.platform_id = 1; 1391 } 1392 if (info->valid & ACPI_VALID_CID) { 1393 cid_list = &info->compatible_id_list; 1394 for (i = 0; i < cid_list->count; i++) 1395 acpi_add_id(pnp, cid_list->ids[i].string); 1396 } 1397 if (info->valid & ACPI_VALID_ADR) { 1398 pnp->bus_address = info->address; 1399 pnp->type.bus_address = 1; 1400 } 1401 if (info->valid & ACPI_VALID_UID) 1402 pnp->unique_id = kstrdup(info->unique_id.string, 1403 GFP_KERNEL); 1404 if (info->valid & ACPI_VALID_CLS) 1405 acpi_add_id(pnp, info->class_code.string); 1406 1407 kfree(info); 1408 1409 /* 1410 * Some devices don't reliably have _HIDs & _CIDs, so add 1411 * synthetic HIDs to make sure drivers can find them. 1412 */ 1413 if (acpi_is_video_device(handle)) { 1414 acpi_add_id(pnp, ACPI_VIDEO_HID); 1415 pnp->type.backlight = 1; 1416 break; 1417 } 1418 if (acpi_bay_match(handle)) 1419 acpi_add_id(pnp, ACPI_BAY_HID); 1420 else if (acpi_dock_match(handle)) 1421 acpi_add_id(pnp, ACPI_DOCK_HID); 1422 else if (acpi_ibm_smbus_match(handle)) 1423 acpi_add_id(pnp, ACPI_SMBUS_IBM_HID); 1424 else if (list_empty(&pnp->ids) && 1425 acpi_object_is_system_bus(handle)) { 1426 /* \_SB, \_TZ, LNXSYBUS */ 1427 acpi_add_id(pnp, ACPI_BUS_HID); 1428 strcpy(pnp->device_name, ACPI_BUS_DEVICE_NAME); 1429 strcpy(pnp->device_class, ACPI_BUS_CLASS); 1430 } 1431 1432 break; 1433 case ACPI_BUS_TYPE_POWER: 1434 acpi_add_id(pnp, ACPI_POWER_HID); 1435 break; 1436 case ACPI_BUS_TYPE_PROCESSOR: 1437 acpi_add_id(pnp, ACPI_PROCESSOR_OBJECT_HID); 1438 break; 1439 case ACPI_BUS_TYPE_THERMAL: 1440 acpi_add_id(pnp, ACPI_THERMAL_HID); 1441 break; 1442 case ACPI_BUS_TYPE_POWER_BUTTON: 1443 acpi_add_id(pnp, ACPI_BUTTON_HID_POWERF); 1444 break; 1445 case ACPI_BUS_TYPE_SLEEP_BUTTON: 1446 acpi_add_id(pnp, ACPI_BUTTON_HID_SLEEPF); 1447 break; 1448 case ACPI_BUS_TYPE_ECDT_EC: 1449 acpi_add_id(pnp, ACPI_ECDT_HID); 1450 break; 1451 } 1452 } 1453 1454 void acpi_free_pnp_ids(struct acpi_device_pnp *pnp) 1455 { 1456 struct acpi_hardware_id *id, *tmp; 1457 1458 list_for_each_entry_safe(id, tmp, &pnp->ids, list) { 1459 kfree_const(id->id); 1460 kfree(id); 1461 } 1462 kfree(pnp->unique_id); 1463 } 1464 1465 /** 1466 * acpi_dma_supported - Check DMA support for the specified device. 1467 * @adev: The pointer to acpi device 1468 * 1469 * Return false if DMA is not supported. Otherwise, return true 1470 */ 1471 bool acpi_dma_supported(const struct acpi_device *adev) 1472 { 1473 if (!adev) 1474 return false; 1475 1476 if (adev->flags.cca_seen) 1477 return true; 1478 1479 /* 1480 * Per ACPI 6.0 sec 6.2.17, assume devices can do cache-coherent 1481 * DMA on "Intel platforms". Presumably that includes all x86 and 1482 * ia64, and other arches will set CONFIG_ACPI_CCA_REQUIRED=y. 1483 */ 1484 if (!IS_ENABLED(CONFIG_ACPI_CCA_REQUIRED)) 1485 return true; 1486 1487 return false; 1488 } 1489 1490 /** 1491 * acpi_get_dma_attr - Check the supported DMA attr for the specified device. 1492 * @adev: The pointer to acpi device 1493 * 1494 * Return enum dev_dma_attr. 1495 */ 1496 enum dev_dma_attr acpi_get_dma_attr(struct acpi_device *adev) 1497 { 1498 if (!acpi_dma_supported(adev)) 1499 return DEV_DMA_NOT_SUPPORTED; 1500 1501 if (adev->flags.coherent_dma) 1502 return DEV_DMA_COHERENT; 1503 else 1504 return DEV_DMA_NON_COHERENT; 1505 } 1506 1507 /** 1508 * acpi_dma_get_range() - Get device DMA parameters. 1509 * 1510 * @dev: device to configure 1511 * @map: pointer to DMA ranges result 1512 * 1513 * Evaluate DMA regions and return pointer to DMA regions on 1514 * parsing success; it does not update the passed in values on failure. 1515 * 1516 * Return 0 on success, < 0 on failure. 1517 */ 1518 int acpi_dma_get_range(struct device *dev, const struct bus_dma_region **map) 1519 { 1520 struct acpi_device *adev; 1521 LIST_HEAD(list); 1522 struct resource_entry *rentry; 1523 int ret; 1524 struct device *dma_dev = dev; 1525 struct bus_dma_region *r; 1526 1527 /* 1528 * Walk the device tree chasing an ACPI companion with a _DMA 1529 * object while we go. Stop if we find a device with an ACPI 1530 * companion containing a _DMA method. 1531 */ 1532 do { 1533 adev = ACPI_COMPANION(dma_dev); 1534 if (adev && acpi_has_method(adev->handle, METHOD_NAME__DMA)) 1535 break; 1536 1537 dma_dev = dma_dev->parent; 1538 } while (dma_dev); 1539 1540 if (!dma_dev) 1541 return -ENODEV; 1542 1543 if (!acpi_has_method(adev->handle, METHOD_NAME__CRS)) { 1544 acpi_handle_warn(adev->handle, "_DMA is valid only if _CRS is present\n"); 1545 return -EINVAL; 1546 } 1547 1548 ret = acpi_dev_get_dma_resources(adev, &list); 1549 if (ret > 0) { 1550 r = kcalloc(ret + 1, sizeof(*r), GFP_KERNEL); 1551 if (!r) { 1552 ret = -ENOMEM; 1553 goto out; 1554 } 1555 1556 *map = r; 1557 1558 list_for_each_entry(rentry, &list, node) { 1559 if (rentry->res->start >= rentry->res->end) { 1560 kfree(*map); 1561 *map = NULL; 1562 ret = -EINVAL; 1563 dev_dbg(dma_dev, "Invalid DMA regions configuration\n"); 1564 goto out; 1565 } 1566 1567 r->cpu_start = rentry->res->start; 1568 r->dma_start = rentry->res->start - rentry->offset; 1569 r->size = resource_size(rentry->res); 1570 r++; 1571 } 1572 } 1573 out: 1574 acpi_dev_free_resource_list(&list); 1575 1576 return ret >= 0 ? 0 : ret; 1577 } 1578 1579 #ifdef CONFIG_IOMMU_API 1580 int acpi_iommu_fwspec_init(struct device *dev, u32 id, 1581 struct fwnode_handle *fwnode, 1582 const struct iommu_ops *ops) 1583 { 1584 int ret = iommu_fwspec_init(dev, fwnode, ops); 1585 1586 if (!ret) 1587 ret = iommu_fwspec_add_ids(dev, &id, 1); 1588 1589 return ret; 1590 } 1591 1592 static inline const struct iommu_ops *acpi_iommu_fwspec_ops(struct device *dev) 1593 { 1594 struct iommu_fwspec *fwspec = dev_iommu_fwspec_get(dev); 1595 1596 return fwspec ? fwspec->ops : NULL; 1597 } 1598 1599 static int acpi_iommu_configure_id(struct device *dev, const u32 *id_in) 1600 { 1601 int err; 1602 const struct iommu_ops *ops; 1603 1604 /* Serialise to make dev->iommu stable under our potential fwspec */ 1605 mutex_lock(&iommu_probe_device_lock); 1606 /* 1607 * If we already translated the fwspec there is nothing left to do, 1608 * return the iommu_ops. 1609 */ 1610 ops = acpi_iommu_fwspec_ops(dev); 1611 if (ops) { 1612 mutex_unlock(&iommu_probe_device_lock); 1613 return 0; 1614 } 1615 1616 err = iort_iommu_configure_id(dev, id_in); 1617 if (err && err != -EPROBE_DEFER) 1618 err = viot_iommu_configure(dev); 1619 mutex_unlock(&iommu_probe_device_lock); 1620 1621 /* 1622 * If we have reason to believe the IOMMU driver missed the initial 1623 * iommu_probe_device() call for dev, replay it to get things in order. 1624 */ 1625 if (!err && dev->bus) 1626 err = iommu_probe_device(dev); 1627 1628 /* Ignore all other errors apart from EPROBE_DEFER */ 1629 if (err == -EPROBE_DEFER) { 1630 return err; 1631 } else if (err) { 1632 dev_dbg(dev, "Adding to IOMMU failed: %d\n", err); 1633 return -ENODEV; 1634 } 1635 if (!acpi_iommu_fwspec_ops(dev)) 1636 return -ENODEV; 1637 return 0; 1638 } 1639 1640 #else /* !CONFIG_IOMMU_API */ 1641 1642 int acpi_iommu_fwspec_init(struct device *dev, u32 id, 1643 struct fwnode_handle *fwnode, 1644 const struct iommu_ops *ops) 1645 { 1646 return -ENODEV; 1647 } 1648 1649 static int acpi_iommu_configure_id(struct device *dev, const u32 *id_in) 1650 { 1651 return -ENODEV; 1652 } 1653 1654 #endif /* !CONFIG_IOMMU_API */ 1655 1656 /** 1657 * acpi_dma_configure_id - Set-up DMA configuration for the device. 1658 * @dev: The pointer to the device 1659 * @attr: device dma attributes 1660 * @input_id: input device id const value pointer 1661 */ 1662 int acpi_dma_configure_id(struct device *dev, enum dev_dma_attr attr, 1663 const u32 *input_id) 1664 { 1665 int ret; 1666 1667 if (attr == DEV_DMA_NOT_SUPPORTED) { 1668 set_dma_ops(dev, &dma_dummy_ops); 1669 return 0; 1670 } 1671 1672 acpi_arch_dma_setup(dev); 1673 1674 ret = acpi_iommu_configure_id(dev, input_id); 1675 if (ret == -EPROBE_DEFER) 1676 return -EPROBE_DEFER; 1677 1678 /* 1679 * Historically this routine doesn't fail driver probing due to errors 1680 * in acpi_iommu_configure_id() 1681 */ 1682 1683 arch_setup_dma_ops(dev, 0, U64_MAX, attr == DEV_DMA_COHERENT); 1684 1685 return 0; 1686 } 1687 EXPORT_SYMBOL_GPL(acpi_dma_configure_id); 1688 1689 static void acpi_init_coherency(struct acpi_device *adev) 1690 { 1691 unsigned long long cca = 0; 1692 acpi_status status; 1693 struct acpi_device *parent = acpi_dev_parent(adev); 1694 1695 if (parent && parent->flags.cca_seen) { 1696 /* 1697 * From ACPI spec, OSPM will ignore _CCA if an ancestor 1698 * already saw one. 1699 */ 1700 adev->flags.cca_seen = 1; 1701 cca = parent->flags.coherent_dma; 1702 } else { 1703 status = acpi_evaluate_integer(adev->handle, "_CCA", 1704 NULL, &cca); 1705 if (ACPI_SUCCESS(status)) 1706 adev->flags.cca_seen = 1; 1707 else if (!IS_ENABLED(CONFIG_ACPI_CCA_REQUIRED)) 1708 /* 1709 * If architecture does not specify that _CCA is 1710 * required for DMA-able devices (e.g. x86), 1711 * we default to _CCA=1. 1712 */ 1713 cca = 1; 1714 else 1715 acpi_handle_debug(adev->handle, 1716 "ACPI device is missing _CCA.\n"); 1717 } 1718 1719 adev->flags.coherent_dma = cca; 1720 } 1721 1722 static int acpi_check_serial_bus_slave(struct acpi_resource *ares, void *data) 1723 { 1724 bool *is_serial_bus_slave_p = data; 1725 1726 if (ares->type != ACPI_RESOURCE_TYPE_SERIAL_BUS) 1727 return 1; 1728 1729 *is_serial_bus_slave_p = true; 1730 1731 /* no need to do more checking */ 1732 return -1; 1733 } 1734 1735 static bool acpi_is_indirect_io_slave(struct acpi_device *device) 1736 { 1737 struct acpi_device *parent = acpi_dev_parent(device); 1738 static const struct acpi_device_id indirect_io_hosts[] = { 1739 {"HISI0191", 0}, 1740 {} 1741 }; 1742 1743 return parent && !acpi_match_device_ids(parent, indirect_io_hosts); 1744 } 1745 1746 static bool acpi_device_enumeration_by_parent(struct acpi_device *device) 1747 { 1748 struct list_head resource_list; 1749 bool is_serial_bus_slave = false; 1750 static const struct acpi_device_id ignore_serial_bus_ids[] = { 1751 /* 1752 * These devices have multiple SerialBus resources and a client 1753 * device must be instantiated for each of them, each with 1754 * its own device id. 1755 * Normally we only instantiate one client device for the first 1756 * resource, using the ACPI HID as id. These special cases are handled 1757 * by the drivers/platform/x86/serial-multi-instantiate.c driver, which 1758 * knows which client device id to use for each resource. 1759 */ 1760 {"BSG1160", }, 1761 {"BSG2150", }, 1762 {"CSC3551", }, 1763 {"CSC3554", }, 1764 {"CSC3556", }, 1765 {"CSC3557", }, 1766 {"INT33FE", }, 1767 {"INT3515", }, 1768 /* Non-conforming _HID for Cirrus Logic already released */ 1769 {"CLSA0100", }, 1770 {"CLSA0101", }, 1771 /* 1772 * Some ACPI devs contain SerialBus resources even though they are not 1773 * attached to a serial bus at all. 1774 */ 1775 {ACPI_VIDEO_HID, }, 1776 {"MSHW0028", }, 1777 /* 1778 * HIDs of device with an UartSerialBusV2 resource for which userspace 1779 * expects a regular tty cdev to be created (instead of the in kernel 1780 * serdev) and which have a kernel driver which expects a platform_dev 1781 * such as the rfkill-gpio driver. 1782 */ 1783 {"BCM4752", }, 1784 {"LNV4752", }, 1785 {} 1786 }; 1787 1788 if (acpi_is_indirect_io_slave(device)) 1789 return true; 1790 1791 /* Macs use device properties in lieu of _CRS resources */ 1792 if (x86_apple_machine && 1793 (fwnode_property_present(&device->fwnode, "spiSclkPeriod") || 1794 fwnode_property_present(&device->fwnode, "i2cAddress") || 1795 fwnode_property_present(&device->fwnode, "baud"))) 1796 return true; 1797 1798 if (!acpi_match_device_ids(device, ignore_serial_bus_ids)) 1799 return false; 1800 1801 INIT_LIST_HEAD(&resource_list); 1802 acpi_dev_get_resources(device, &resource_list, 1803 acpi_check_serial_bus_slave, 1804 &is_serial_bus_slave); 1805 acpi_dev_free_resource_list(&resource_list); 1806 1807 return is_serial_bus_slave; 1808 } 1809 1810 void acpi_init_device_object(struct acpi_device *device, acpi_handle handle, 1811 int type, void (*release)(struct device *)) 1812 { 1813 struct acpi_device *parent = acpi_find_parent_acpi_dev(handle); 1814 1815 INIT_LIST_HEAD(&device->pnp.ids); 1816 device->device_type = type; 1817 device->handle = handle; 1818 device->dev.parent = parent ? &parent->dev : NULL; 1819 device->dev.release = release; 1820 device->dev.bus = &acpi_bus_type; 1821 fwnode_init(&device->fwnode, &acpi_device_fwnode_ops); 1822 acpi_set_device_status(device, ACPI_STA_DEFAULT); 1823 acpi_device_get_busid(device); 1824 acpi_set_pnp_ids(handle, &device->pnp, type); 1825 acpi_init_properties(device); 1826 acpi_bus_get_flags(device); 1827 device->flags.match_driver = false; 1828 device->flags.initialized = true; 1829 device->flags.enumeration_by_parent = 1830 acpi_device_enumeration_by_parent(device); 1831 acpi_device_clear_enumerated(device); 1832 device_initialize(&device->dev); 1833 dev_set_uevent_suppress(&device->dev, true); 1834 acpi_init_coherency(device); 1835 } 1836 1837 static void acpi_scan_dep_init(struct acpi_device *adev) 1838 { 1839 struct acpi_dep_data *dep; 1840 1841 list_for_each_entry(dep, &acpi_dep_list, node) { 1842 if (dep->consumer == adev->handle) { 1843 if (dep->honor_dep) 1844 adev->flags.honor_deps = 1; 1845 1846 adev->dep_unmet++; 1847 } 1848 } 1849 } 1850 1851 void acpi_device_add_finalize(struct acpi_device *device) 1852 { 1853 dev_set_uevent_suppress(&device->dev, false); 1854 kobject_uevent(&device->dev.kobj, KOBJ_ADD); 1855 } 1856 1857 static void acpi_scan_init_status(struct acpi_device *adev) 1858 { 1859 if (acpi_bus_get_status(adev)) 1860 acpi_set_device_status(adev, 0); 1861 } 1862 1863 static int acpi_add_single_object(struct acpi_device **child, 1864 acpi_handle handle, int type, bool dep_init) 1865 { 1866 struct acpi_device *device; 1867 bool release_dep_lock = false; 1868 int result; 1869 1870 device = kzalloc(sizeof(struct acpi_device), GFP_KERNEL); 1871 if (!device) 1872 return -ENOMEM; 1873 1874 acpi_init_device_object(device, handle, type, acpi_device_release); 1875 /* 1876 * Getting the status is delayed till here so that we can call 1877 * acpi_bus_get_status() and use its quirk handling. Note that 1878 * this must be done before the get power-/wakeup_dev-flags calls. 1879 */ 1880 if (type == ACPI_BUS_TYPE_DEVICE || type == ACPI_BUS_TYPE_PROCESSOR) { 1881 if (dep_init) { 1882 mutex_lock(&acpi_dep_list_lock); 1883 /* 1884 * Hold the lock until the acpi_tie_acpi_dev() call 1885 * below to prevent concurrent acpi_scan_clear_dep() 1886 * from deleting a dependency list entry without 1887 * updating dep_unmet for the device. 1888 */ 1889 release_dep_lock = true; 1890 acpi_scan_dep_init(device); 1891 } 1892 acpi_scan_init_status(device); 1893 } 1894 1895 acpi_bus_get_power_flags(device); 1896 acpi_bus_get_wakeup_device_flags(device); 1897 1898 result = acpi_tie_acpi_dev(device); 1899 1900 if (release_dep_lock) 1901 mutex_unlock(&acpi_dep_list_lock); 1902 1903 if (!result) 1904 result = acpi_device_add(device); 1905 1906 if (result) { 1907 acpi_device_release(&device->dev); 1908 return result; 1909 } 1910 1911 acpi_power_add_remove_device(device, true); 1912 acpi_device_add_finalize(device); 1913 1914 acpi_handle_debug(handle, "Added as %s, parent %s\n", 1915 dev_name(&device->dev), device->dev.parent ? 1916 dev_name(device->dev.parent) : "(null)"); 1917 1918 *child = device; 1919 return 0; 1920 } 1921 1922 static acpi_status acpi_get_resource_memory(struct acpi_resource *ares, 1923 void *context) 1924 { 1925 struct resource *res = context; 1926 1927 if (acpi_dev_resource_memory(ares, res)) 1928 return AE_CTRL_TERMINATE; 1929 1930 return AE_OK; 1931 } 1932 1933 static bool acpi_device_should_be_hidden(acpi_handle handle) 1934 { 1935 acpi_status status; 1936 struct resource res; 1937 1938 /* Check if it should ignore the UART device */ 1939 if (!(spcr_uart_addr && acpi_has_method(handle, METHOD_NAME__CRS))) 1940 return false; 1941 1942 /* 1943 * The UART device described in SPCR table is assumed to have only one 1944 * memory resource present. So we only look for the first one here. 1945 */ 1946 status = acpi_walk_resources(handle, METHOD_NAME__CRS, 1947 acpi_get_resource_memory, &res); 1948 if (ACPI_FAILURE(status) || res.start != spcr_uart_addr) 1949 return false; 1950 1951 acpi_handle_info(handle, "The UART device @%pa in SPCR table will be hidden\n", 1952 &res.start); 1953 1954 return true; 1955 } 1956 1957 bool acpi_device_is_present(const struct acpi_device *adev) 1958 { 1959 return adev->status.present || adev->status.functional; 1960 } 1961 1962 bool acpi_device_is_enabled(const struct acpi_device *adev) 1963 { 1964 return adev->status.present && adev->status.enabled; 1965 } 1966 1967 static bool acpi_scan_handler_matching(struct acpi_scan_handler *handler, 1968 const char *idstr, 1969 const struct acpi_device_id **matchid) 1970 { 1971 const struct acpi_device_id *devid; 1972 1973 if (handler->match) 1974 return handler->match(idstr, matchid); 1975 1976 for (devid = handler->ids; devid->id[0]; devid++) 1977 if (!strcmp((char *)devid->id, idstr)) { 1978 if (matchid) 1979 *matchid = devid; 1980 1981 return true; 1982 } 1983 1984 return false; 1985 } 1986 1987 static struct acpi_scan_handler *acpi_scan_match_handler(const char *idstr, 1988 const struct acpi_device_id **matchid) 1989 { 1990 struct acpi_scan_handler *handler; 1991 1992 list_for_each_entry(handler, &acpi_scan_handlers_list, list_node) 1993 if (acpi_scan_handler_matching(handler, idstr, matchid)) 1994 return handler; 1995 1996 return NULL; 1997 } 1998 1999 void acpi_scan_hotplug_enabled(struct acpi_hotplug_profile *hotplug, bool val) 2000 { 2001 if (!!hotplug->enabled == !!val) 2002 return; 2003 2004 mutex_lock(&acpi_scan_lock); 2005 2006 hotplug->enabled = val; 2007 2008 mutex_unlock(&acpi_scan_lock); 2009 } 2010 2011 static void acpi_scan_init_hotplug(struct acpi_device *adev) 2012 { 2013 struct acpi_hardware_id *hwid; 2014 2015 if (acpi_dock_match(adev->handle) || is_ejectable_bay(adev)) { 2016 acpi_dock_add(adev); 2017 return; 2018 } 2019 list_for_each_entry(hwid, &adev->pnp.ids, list) { 2020 struct acpi_scan_handler *handler; 2021 2022 handler = acpi_scan_match_handler(hwid->id, NULL); 2023 if (handler) { 2024 adev->flags.hotplug_notify = true; 2025 break; 2026 } 2027 } 2028 } 2029 2030 static u32 acpi_scan_check_dep(acpi_handle handle) 2031 { 2032 struct acpi_handle_list dep_devices; 2033 u32 count; 2034 int i; 2035 2036 /* 2037 * Check for _HID here to avoid deferring the enumeration of: 2038 * 1. PCI devices. 2039 * 2. ACPI nodes describing USB ports. 2040 * Still, checking for _HID catches more then just these cases ... 2041 */ 2042 if (!acpi_has_method(handle, "_DEP") || !acpi_has_method(handle, "_HID")) 2043 return 0; 2044 2045 if (!acpi_evaluate_reference(handle, "_DEP", NULL, &dep_devices)) { 2046 acpi_handle_debug(handle, "Failed to evaluate _DEP.\n"); 2047 return 0; 2048 } 2049 2050 for (count = 0, i = 0; i < dep_devices.count; i++) { 2051 struct acpi_device_info *info; 2052 struct acpi_dep_data *dep; 2053 bool skip, honor_dep; 2054 acpi_status status; 2055 2056 status = acpi_get_object_info(dep_devices.handles[i], &info); 2057 if (ACPI_FAILURE(status)) { 2058 acpi_handle_debug(handle, "Error reading _DEP device info\n"); 2059 continue; 2060 } 2061 2062 skip = acpi_info_matches_ids(info, acpi_ignore_dep_ids); 2063 honor_dep = acpi_info_matches_ids(info, acpi_honor_dep_ids); 2064 kfree(info); 2065 2066 if (skip) 2067 continue; 2068 2069 dep = kzalloc(sizeof(*dep), GFP_KERNEL); 2070 if (!dep) 2071 continue; 2072 2073 count++; 2074 2075 dep->supplier = dep_devices.handles[i]; 2076 dep->consumer = handle; 2077 dep->honor_dep = honor_dep; 2078 2079 mutex_lock(&acpi_dep_list_lock); 2080 list_add_tail(&dep->node , &acpi_dep_list); 2081 mutex_unlock(&acpi_dep_list_lock); 2082 } 2083 2084 acpi_handle_list_free(&dep_devices); 2085 return count; 2086 } 2087 2088 static acpi_status acpi_scan_check_crs_csi2_cb(acpi_handle handle, u32 a, void *b, void **c) 2089 { 2090 acpi_mipi_check_crs_csi2(handle); 2091 return AE_OK; 2092 } 2093 2094 static acpi_status acpi_bus_check_add(acpi_handle handle, bool first_pass, 2095 struct acpi_device **adev_p) 2096 { 2097 struct acpi_device *device = acpi_fetch_acpi_dev(handle); 2098 acpi_object_type acpi_type; 2099 int type; 2100 2101 if (device) 2102 goto out; 2103 2104 if (ACPI_FAILURE(acpi_get_type(handle, &acpi_type))) 2105 return AE_OK; 2106 2107 switch (acpi_type) { 2108 case ACPI_TYPE_DEVICE: 2109 if (acpi_device_should_be_hidden(handle)) 2110 return AE_OK; 2111 2112 if (first_pass) { 2113 acpi_mipi_check_crs_csi2(handle); 2114 2115 /* Bail out if there are dependencies. */ 2116 if (acpi_scan_check_dep(handle) > 0) { 2117 /* 2118 * The entire CSI-2 connection graph needs to be 2119 * extracted before any drivers or scan handlers 2120 * are bound to struct device objects, so scan 2121 * _CRS CSI-2 resource descriptors for all 2122 * devices below the current handle. 2123 */ 2124 acpi_walk_namespace(ACPI_TYPE_DEVICE, handle, 2125 ACPI_UINT32_MAX, 2126 acpi_scan_check_crs_csi2_cb, 2127 NULL, NULL, NULL); 2128 return AE_CTRL_DEPTH; 2129 } 2130 } 2131 2132 fallthrough; 2133 case ACPI_TYPE_ANY: /* for ACPI_ROOT_OBJECT */ 2134 type = ACPI_BUS_TYPE_DEVICE; 2135 break; 2136 2137 case ACPI_TYPE_PROCESSOR: 2138 type = ACPI_BUS_TYPE_PROCESSOR; 2139 break; 2140 2141 case ACPI_TYPE_THERMAL: 2142 type = ACPI_BUS_TYPE_THERMAL; 2143 break; 2144 2145 case ACPI_TYPE_POWER: 2146 acpi_add_power_resource(handle); 2147 fallthrough; 2148 default: 2149 return AE_OK; 2150 } 2151 2152 /* 2153 * If first_pass is true at this point, the device has no dependencies, 2154 * or the creation of the device object would have been postponed above. 2155 */ 2156 acpi_add_single_object(&device, handle, type, !first_pass); 2157 if (!device) 2158 return AE_CTRL_DEPTH; 2159 2160 acpi_scan_init_hotplug(device); 2161 2162 out: 2163 if (!*adev_p) 2164 *adev_p = device; 2165 2166 return AE_OK; 2167 } 2168 2169 static acpi_status acpi_bus_check_add_1(acpi_handle handle, u32 lvl_not_used, 2170 void *not_used, void **ret_p) 2171 { 2172 return acpi_bus_check_add(handle, true, (struct acpi_device **)ret_p); 2173 } 2174 2175 static acpi_status acpi_bus_check_add_2(acpi_handle handle, u32 lvl_not_used, 2176 void *not_used, void **ret_p) 2177 { 2178 return acpi_bus_check_add(handle, false, (struct acpi_device **)ret_p); 2179 } 2180 2181 static void acpi_default_enumeration(struct acpi_device *device) 2182 { 2183 /* 2184 * Do not enumerate devices with enumeration_by_parent flag set as 2185 * they will be enumerated by their respective parents. 2186 */ 2187 if (!device->flags.enumeration_by_parent) { 2188 acpi_create_platform_device(device, NULL); 2189 acpi_device_set_enumerated(device); 2190 } else { 2191 blocking_notifier_call_chain(&acpi_reconfig_chain, 2192 ACPI_RECONFIG_DEVICE_ADD, device); 2193 } 2194 } 2195 2196 static const struct acpi_device_id generic_device_ids[] = { 2197 {ACPI_DT_NAMESPACE_HID, }, 2198 {"", }, 2199 }; 2200 2201 static int acpi_generic_device_attach(struct acpi_device *adev, 2202 const struct acpi_device_id *not_used) 2203 { 2204 /* 2205 * Since ACPI_DT_NAMESPACE_HID is the only ID handled here, the test 2206 * below can be unconditional. 2207 */ 2208 if (adev->data.of_compatible) 2209 acpi_default_enumeration(adev); 2210 2211 return 1; 2212 } 2213 2214 static struct acpi_scan_handler generic_device_handler = { 2215 .ids = generic_device_ids, 2216 .attach = acpi_generic_device_attach, 2217 }; 2218 2219 static int acpi_scan_attach_handler(struct acpi_device *device) 2220 { 2221 struct acpi_hardware_id *hwid; 2222 int ret = 0; 2223 2224 list_for_each_entry(hwid, &device->pnp.ids, list) { 2225 const struct acpi_device_id *devid; 2226 struct acpi_scan_handler *handler; 2227 2228 handler = acpi_scan_match_handler(hwid->id, &devid); 2229 if (handler) { 2230 if (!handler->attach) { 2231 device->pnp.type.platform_id = 0; 2232 continue; 2233 } 2234 device->handler = handler; 2235 ret = handler->attach(device, devid); 2236 if (ret > 0) 2237 break; 2238 2239 device->handler = NULL; 2240 if (ret < 0) 2241 break; 2242 } 2243 } 2244 2245 return ret; 2246 } 2247 2248 static int acpi_bus_attach(struct acpi_device *device, void *first_pass) 2249 { 2250 bool skip = !first_pass && device->flags.visited; 2251 acpi_handle ejd; 2252 int ret; 2253 2254 if (skip) 2255 goto ok; 2256 2257 if (ACPI_SUCCESS(acpi_bus_get_ejd(device->handle, &ejd))) 2258 register_dock_dependent_device(device, ejd); 2259 2260 acpi_bus_get_status(device); 2261 /* Skip devices that are not ready for enumeration (e.g. not present) */ 2262 if (!acpi_dev_ready_for_enumeration(device)) { 2263 device->flags.initialized = false; 2264 acpi_device_clear_enumerated(device); 2265 device->flags.power_manageable = 0; 2266 return 0; 2267 } 2268 if (device->handler) 2269 goto ok; 2270 2271 if (!device->flags.initialized) { 2272 device->flags.power_manageable = 2273 device->power.states[ACPI_STATE_D0].flags.valid; 2274 if (acpi_bus_init_power(device)) 2275 device->flags.power_manageable = 0; 2276 2277 device->flags.initialized = true; 2278 } else if (device->flags.visited) { 2279 goto ok; 2280 } 2281 2282 ret = acpi_scan_attach_handler(device); 2283 if (ret < 0) 2284 return 0; 2285 2286 device->flags.match_driver = true; 2287 if (ret > 0 && !device->flags.enumeration_by_parent) { 2288 acpi_device_set_enumerated(device); 2289 goto ok; 2290 } 2291 2292 ret = device_attach(&device->dev); 2293 if (ret < 0) 2294 return 0; 2295 2296 if (device->pnp.type.platform_id || device->flags.enumeration_by_parent) 2297 acpi_default_enumeration(device); 2298 else 2299 acpi_device_set_enumerated(device); 2300 2301 ok: 2302 acpi_dev_for_each_child(device, acpi_bus_attach, first_pass); 2303 2304 if (!skip && device->handler && device->handler->hotplug.notify_online) 2305 device->handler->hotplug.notify_online(device); 2306 2307 return 0; 2308 } 2309 2310 static int acpi_dev_get_next_consumer_dev_cb(struct acpi_dep_data *dep, void *data) 2311 { 2312 struct acpi_device **adev_p = data; 2313 struct acpi_device *adev = *adev_p; 2314 2315 /* 2316 * If we're passed a 'previous' consumer device then we need to skip 2317 * any consumers until we meet the previous one, and then NULL @data 2318 * so the next one can be returned. 2319 */ 2320 if (adev) { 2321 if (dep->consumer == adev->handle) 2322 *adev_p = NULL; 2323 2324 return 0; 2325 } 2326 2327 adev = acpi_get_acpi_dev(dep->consumer); 2328 if (adev) { 2329 *(struct acpi_device **)data = adev; 2330 return 1; 2331 } 2332 /* Continue parsing if the device object is not present. */ 2333 return 0; 2334 } 2335 2336 struct acpi_scan_clear_dep_work { 2337 struct work_struct work; 2338 struct acpi_device *adev; 2339 }; 2340 2341 static void acpi_scan_clear_dep_fn(struct work_struct *work) 2342 { 2343 struct acpi_scan_clear_dep_work *cdw; 2344 2345 cdw = container_of(work, struct acpi_scan_clear_dep_work, work); 2346 2347 acpi_scan_lock_acquire(); 2348 acpi_bus_attach(cdw->adev, (void *)true); 2349 acpi_scan_lock_release(); 2350 2351 acpi_dev_put(cdw->adev); 2352 kfree(cdw); 2353 } 2354 2355 static bool acpi_scan_clear_dep_queue(struct acpi_device *adev) 2356 { 2357 struct acpi_scan_clear_dep_work *cdw; 2358 2359 if (adev->dep_unmet) 2360 return false; 2361 2362 cdw = kmalloc(sizeof(*cdw), GFP_KERNEL); 2363 if (!cdw) 2364 return false; 2365 2366 cdw->adev = adev; 2367 INIT_WORK(&cdw->work, acpi_scan_clear_dep_fn); 2368 /* 2369 * Since the work function may block on the lock until the entire 2370 * initial enumeration of devices is complete, put it into the unbound 2371 * workqueue. 2372 */ 2373 queue_work(system_unbound_wq, &cdw->work); 2374 2375 return true; 2376 } 2377 2378 static void acpi_scan_delete_dep_data(struct acpi_dep_data *dep) 2379 { 2380 list_del(&dep->node); 2381 kfree(dep); 2382 } 2383 2384 static int acpi_scan_clear_dep(struct acpi_dep_data *dep, void *data) 2385 { 2386 struct acpi_device *adev = acpi_get_acpi_dev(dep->consumer); 2387 2388 if (adev) { 2389 adev->dep_unmet--; 2390 if (!acpi_scan_clear_dep_queue(adev)) 2391 acpi_dev_put(adev); 2392 } 2393 2394 if (dep->free_when_met) 2395 acpi_scan_delete_dep_data(dep); 2396 else 2397 dep->met = true; 2398 2399 return 0; 2400 } 2401 2402 /** 2403 * acpi_walk_dep_device_list - Apply a callback to every entry in acpi_dep_list 2404 * @handle: The ACPI handle of the supplier device 2405 * @callback: Pointer to the callback function to apply 2406 * @data: Pointer to some data to pass to the callback 2407 * 2408 * The return value of the callback determines this function's behaviour. If 0 2409 * is returned we continue to iterate over acpi_dep_list. If a positive value 2410 * is returned then the loop is broken but this function returns 0. If a 2411 * negative value is returned by the callback then the loop is broken and that 2412 * value is returned as the final error. 2413 */ 2414 static int acpi_walk_dep_device_list(acpi_handle handle, 2415 int (*callback)(struct acpi_dep_data *, void *), 2416 void *data) 2417 { 2418 struct acpi_dep_data *dep, *tmp; 2419 int ret = 0; 2420 2421 mutex_lock(&acpi_dep_list_lock); 2422 list_for_each_entry_safe(dep, tmp, &acpi_dep_list, node) { 2423 if (dep->supplier == handle) { 2424 ret = callback(dep, data); 2425 if (ret) 2426 break; 2427 } 2428 } 2429 mutex_unlock(&acpi_dep_list_lock); 2430 2431 return ret > 0 ? 0 : ret; 2432 } 2433 2434 /** 2435 * acpi_dev_clear_dependencies - Inform consumers that the device is now active 2436 * @supplier: Pointer to the supplier &struct acpi_device 2437 * 2438 * Clear dependencies on the given device. 2439 */ 2440 void acpi_dev_clear_dependencies(struct acpi_device *supplier) 2441 { 2442 acpi_walk_dep_device_list(supplier->handle, acpi_scan_clear_dep, NULL); 2443 } 2444 EXPORT_SYMBOL_GPL(acpi_dev_clear_dependencies); 2445 2446 /** 2447 * acpi_dev_ready_for_enumeration - Check if the ACPI device is ready for enumeration 2448 * @device: Pointer to the &struct acpi_device to check 2449 * 2450 * Check if the device is present and has no unmet dependencies. 2451 * 2452 * Return true if the device is ready for enumeratino. Otherwise, return false. 2453 */ 2454 bool acpi_dev_ready_for_enumeration(const struct acpi_device *device) 2455 { 2456 if (device->flags.honor_deps && device->dep_unmet) 2457 return false; 2458 2459 return acpi_device_is_present(device); 2460 } 2461 EXPORT_SYMBOL_GPL(acpi_dev_ready_for_enumeration); 2462 2463 /** 2464 * acpi_dev_get_next_consumer_dev - Return the next adev dependent on @supplier 2465 * @supplier: Pointer to the dependee device 2466 * @start: Pointer to the current dependent device 2467 * 2468 * Returns the next &struct acpi_device which declares itself dependent on 2469 * @supplier via the _DEP buffer, parsed from the acpi_dep_list. 2470 * 2471 * If the returned adev is not passed as @start to this function, the caller is 2472 * responsible for putting the reference to adev when it is no longer needed. 2473 */ 2474 struct acpi_device *acpi_dev_get_next_consumer_dev(struct acpi_device *supplier, 2475 struct acpi_device *start) 2476 { 2477 struct acpi_device *adev = start; 2478 2479 acpi_walk_dep_device_list(supplier->handle, 2480 acpi_dev_get_next_consumer_dev_cb, &adev); 2481 2482 acpi_dev_put(start); 2483 2484 if (adev == start) 2485 return NULL; 2486 2487 return adev; 2488 } 2489 EXPORT_SYMBOL_GPL(acpi_dev_get_next_consumer_dev); 2490 2491 static void acpi_scan_postponed_branch(acpi_handle handle) 2492 { 2493 struct acpi_device *adev = NULL; 2494 2495 if (ACPI_FAILURE(acpi_bus_check_add(handle, false, &adev))) 2496 return; 2497 2498 acpi_walk_namespace(ACPI_TYPE_ANY, handle, ACPI_UINT32_MAX, 2499 acpi_bus_check_add_2, NULL, NULL, (void **)&adev); 2500 2501 /* 2502 * Populate the ACPI _CRS CSI-2 software nodes for the ACPI devices that 2503 * have been added above. 2504 */ 2505 acpi_mipi_init_crs_csi2_swnodes(); 2506 2507 acpi_bus_attach(adev, NULL); 2508 } 2509 2510 static void acpi_scan_postponed(void) 2511 { 2512 struct acpi_dep_data *dep, *tmp; 2513 2514 mutex_lock(&acpi_dep_list_lock); 2515 2516 list_for_each_entry_safe(dep, tmp, &acpi_dep_list, node) { 2517 acpi_handle handle = dep->consumer; 2518 2519 /* 2520 * In case there are multiple acpi_dep_list entries with the 2521 * same consumer, skip the current entry if the consumer device 2522 * object corresponding to it is present already. 2523 */ 2524 if (!acpi_fetch_acpi_dev(handle)) { 2525 /* 2526 * Even though the lock is released here, tmp is 2527 * guaranteed to be valid, because none of the list 2528 * entries following dep is marked as "free when met" 2529 * and so they cannot be deleted. 2530 */ 2531 mutex_unlock(&acpi_dep_list_lock); 2532 2533 acpi_scan_postponed_branch(handle); 2534 2535 mutex_lock(&acpi_dep_list_lock); 2536 } 2537 2538 if (dep->met) 2539 acpi_scan_delete_dep_data(dep); 2540 else 2541 dep->free_when_met = true; 2542 } 2543 2544 mutex_unlock(&acpi_dep_list_lock); 2545 } 2546 2547 /** 2548 * acpi_bus_scan - Add ACPI device node objects in a given namespace scope. 2549 * @handle: Root of the namespace scope to scan. 2550 * 2551 * Scan a given ACPI tree (probably recently hot-plugged) and create and add 2552 * found devices. 2553 * 2554 * If no devices were found, -ENODEV is returned, but it does not mean that 2555 * there has been a real error. There just have been no suitable ACPI objects 2556 * in the table trunk from which the kernel could create a device and add an 2557 * appropriate driver. 2558 * 2559 * Must be called under acpi_scan_lock. 2560 */ 2561 int acpi_bus_scan(acpi_handle handle) 2562 { 2563 struct acpi_device *device = NULL; 2564 2565 /* Pass 1: Avoid enumerating devices with missing dependencies. */ 2566 2567 if (ACPI_SUCCESS(acpi_bus_check_add(handle, true, &device))) 2568 acpi_walk_namespace(ACPI_TYPE_ANY, handle, ACPI_UINT32_MAX, 2569 acpi_bus_check_add_1, NULL, NULL, 2570 (void **)&device); 2571 2572 if (!device) 2573 return -ENODEV; 2574 2575 /* 2576 * Set up ACPI _CRS CSI-2 software nodes using information extracted 2577 * from the _CRS CSI-2 resource descriptors during the ACPI namespace 2578 * walk above and MIPI DisCo for Imaging device properties. 2579 */ 2580 acpi_mipi_scan_crs_csi2(); 2581 acpi_mipi_init_crs_csi2_swnodes(); 2582 2583 acpi_bus_attach(device, (void *)true); 2584 2585 /* Pass 2: Enumerate all of the remaining devices. */ 2586 2587 acpi_scan_postponed(); 2588 2589 acpi_mipi_crs_csi2_cleanup(); 2590 2591 return 0; 2592 } 2593 EXPORT_SYMBOL(acpi_bus_scan); 2594 2595 /** 2596 * acpi_bus_trim - Detach scan handlers and drivers from ACPI device objects. 2597 * @adev: Root of the ACPI namespace scope to walk. 2598 * 2599 * Must be called under acpi_scan_lock. 2600 */ 2601 void acpi_bus_trim(struct acpi_device *adev) 2602 { 2603 acpi_scan_check_and_detach(adev, NULL); 2604 } 2605 EXPORT_SYMBOL_GPL(acpi_bus_trim); 2606 2607 int acpi_bus_register_early_device(int type) 2608 { 2609 struct acpi_device *device = NULL; 2610 int result; 2611 2612 result = acpi_add_single_object(&device, NULL, type, false); 2613 if (result) 2614 return result; 2615 2616 device->flags.match_driver = true; 2617 return device_attach(&device->dev); 2618 } 2619 EXPORT_SYMBOL_GPL(acpi_bus_register_early_device); 2620 2621 static void acpi_bus_scan_fixed(void) 2622 { 2623 if (!(acpi_gbl_FADT.flags & ACPI_FADT_POWER_BUTTON)) { 2624 struct acpi_device *adev = NULL; 2625 2626 acpi_add_single_object(&adev, NULL, ACPI_BUS_TYPE_POWER_BUTTON, 2627 false); 2628 if (adev) { 2629 adev->flags.match_driver = true; 2630 if (device_attach(&adev->dev) >= 0) 2631 device_init_wakeup(&adev->dev, true); 2632 else 2633 dev_dbg(&adev->dev, "No driver\n"); 2634 } 2635 } 2636 2637 if (!(acpi_gbl_FADT.flags & ACPI_FADT_SLEEP_BUTTON)) { 2638 struct acpi_device *adev = NULL; 2639 2640 acpi_add_single_object(&adev, NULL, ACPI_BUS_TYPE_SLEEP_BUTTON, 2641 false); 2642 if (adev) { 2643 adev->flags.match_driver = true; 2644 if (device_attach(&adev->dev) < 0) 2645 dev_dbg(&adev->dev, "No driver\n"); 2646 } 2647 } 2648 } 2649 2650 static void __init acpi_get_spcr_uart_addr(void) 2651 { 2652 acpi_status status; 2653 struct acpi_table_spcr *spcr_ptr; 2654 2655 status = acpi_get_table(ACPI_SIG_SPCR, 0, 2656 (struct acpi_table_header **)&spcr_ptr); 2657 if (ACPI_FAILURE(status)) { 2658 pr_warn("STAO table present, but SPCR is missing\n"); 2659 return; 2660 } 2661 2662 spcr_uart_addr = spcr_ptr->serial_port.address; 2663 acpi_put_table((struct acpi_table_header *)spcr_ptr); 2664 } 2665 2666 static bool acpi_scan_initialized; 2667 2668 void __init acpi_scan_init(void) 2669 { 2670 acpi_status status; 2671 struct acpi_table_stao *stao_ptr; 2672 2673 acpi_pci_root_init(); 2674 acpi_pci_link_init(); 2675 acpi_processor_init(); 2676 acpi_platform_init(); 2677 acpi_lpss_init(); 2678 acpi_apd_init(); 2679 acpi_cmos_rtc_init(); 2680 acpi_container_init(); 2681 acpi_memory_hotplug_init(); 2682 acpi_watchdog_init(); 2683 acpi_pnp_init(); 2684 acpi_int340x_thermal_init(); 2685 acpi_init_lpit(); 2686 2687 acpi_scan_add_handler(&generic_device_handler); 2688 2689 /* 2690 * If there is STAO table, check whether it needs to ignore the UART 2691 * device in SPCR table. 2692 */ 2693 status = acpi_get_table(ACPI_SIG_STAO, 0, 2694 (struct acpi_table_header **)&stao_ptr); 2695 if (ACPI_SUCCESS(status)) { 2696 if (stao_ptr->header.length > sizeof(struct acpi_table_stao)) 2697 pr_info("STAO Name List not yet supported.\n"); 2698 2699 if (stao_ptr->ignore_uart) 2700 acpi_get_spcr_uart_addr(); 2701 2702 acpi_put_table((struct acpi_table_header *)stao_ptr); 2703 } 2704 2705 acpi_gpe_apply_masked_gpes(); 2706 acpi_update_all_gpes(); 2707 2708 /* 2709 * Although we call __add_memory() that is documented to require the 2710 * device_hotplug_lock, it is not necessary here because this is an 2711 * early code when userspace or any other code path cannot trigger 2712 * hotplug/hotunplug operations. 2713 */ 2714 mutex_lock(&acpi_scan_lock); 2715 /* 2716 * Enumerate devices in the ACPI namespace. 2717 */ 2718 if (acpi_bus_scan(ACPI_ROOT_OBJECT)) 2719 goto unlock; 2720 2721 acpi_root = acpi_fetch_acpi_dev(ACPI_ROOT_OBJECT); 2722 if (!acpi_root) 2723 goto unlock; 2724 2725 /* Fixed feature devices do not exist on HW-reduced platform */ 2726 if (!acpi_gbl_reduced_hardware) 2727 acpi_bus_scan_fixed(); 2728 2729 acpi_turn_off_unused_power_resources(); 2730 2731 acpi_scan_initialized = true; 2732 2733 unlock: 2734 mutex_unlock(&acpi_scan_lock); 2735 } 2736 2737 static struct acpi_probe_entry *ape; 2738 static int acpi_probe_count; 2739 static DEFINE_MUTEX(acpi_probe_mutex); 2740 2741 static int __init acpi_match_madt(union acpi_subtable_headers *header, 2742 const unsigned long end) 2743 { 2744 if (!ape->subtable_valid || ape->subtable_valid(&header->common, ape)) 2745 if (!ape->probe_subtbl(header, end)) 2746 acpi_probe_count++; 2747 2748 return 0; 2749 } 2750 2751 int __init __acpi_probe_device_table(struct acpi_probe_entry *ap_head, int nr) 2752 { 2753 int count = 0; 2754 2755 if (acpi_disabled) 2756 return 0; 2757 2758 mutex_lock(&acpi_probe_mutex); 2759 for (ape = ap_head; nr; ape++, nr--) { 2760 if (ACPI_COMPARE_NAMESEG(ACPI_SIG_MADT, ape->id)) { 2761 acpi_probe_count = 0; 2762 acpi_table_parse_madt(ape->type, acpi_match_madt, 0); 2763 count += acpi_probe_count; 2764 } else { 2765 int res; 2766 res = acpi_table_parse(ape->id, ape->probe_table); 2767 if (!res) 2768 count++; 2769 } 2770 } 2771 mutex_unlock(&acpi_probe_mutex); 2772 2773 return count; 2774 } 2775 2776 static void acpi_table_events_fn(struct work_struct *work) 2777 { 2778 acpi_scan_lock_acquire(); 2779 acpi_bus_scan(ACPI_ROOT_OBJECT); 2780 acpi_scan_lock_release(); 2781 2782 kfree(work); 2783 } 2784 2785 void acpi_scan_table_notify(void) 2786 { 2787 struct work_struct *work; 2788 2789 if (!acpi_scan_initialized) 2790 return; 2791 2792 work = kmalloc(sizeof(*work), GFP_KERNEL); 2793 if (!work) 2794 return; 2795 2796 INIT_WORK(work, acpi_table_events_fn); 2797 schedule_work(work); 2798 } 2799 2800 int acpi_reconfig_notifier_register(struct notifier_block *nb) 2801 { 2802 return blocking_notifier_chain_register(&acpi_reconfig_chain, nb); 2803 } 2804 EXPORT_SYMBOL(acpi_reconfig_notifier_register); 2805 2806 int acpi_reconfig_notifier_unregister(struct notifier_block *nb) 2807 { 2808 return blocking_notifier_chain_unregister(&acpi_reconfig_chain, nb); 2809 } 2810 EXPORT_SYMBOL(acpi_reconfig_notifier_unregister); 2811