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