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