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