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