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