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