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