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