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 14 #include <acpi/acpi_drivers.h> 15 16 #include "internal.h" 17 18 #define _COMPONENT ACPI_BUS_COMPONENT 19 ACPI_MODULE_NAME("scan"); 20 #define STRUCT_TO_INT(s) (*((int*)&s)) 21 extern struct acpi_device *acpi_root; 22 23 #define ACPI_BUS_CLASS "system_bus" 24 #define ACPI_BUS_HID "LNXSYBUS" 25 #define ACPI_BUS_DEVICE_NAME "System Bus" 26 27 #define ACPI_IS_ROOT_DEVICE(device) (!(device)->parent) 28 29 static const char *dummy_hid = "device"; 30 31 static LIST_HEAD(acpi_device_list); 32 static LIST_HEAD(acpi_bus_id_list); 33 DEFINE_MUTEX(acpi_device_lock); 34 LIST_HEAD(acpi_wakeup_device_list); 35 36 struct acpi_device_bus_id{ 37 char bus_id[15]; 38 unsigned int instance_no; 39 struct list_head node; 40 }; 41 42 /* 43 * Creates hid/cid(s) string needed for modalias and uevent 44 * e.g. on a device with hid:IBM0001 and cid:ACPI0001 you get: 45 * char *modalias: "acpi:IBM0001:ACPI0001" 46 */ 47 static int create_modalias(struct acpi_device *acpi_dev, char *modalias, 48 int size) 49 { 50 int len; 51 int count; 52 struct acpi_hardware_id *id; 53 54 if (list_empty(&acpi_dev->pnp.ids)) 55 return 0; 56 57 len = snprintf(modalias, size, "acpi:"); 58 size -= len; 59 60 list_for_each_entry(id, &acpi_dev->pnp.ids, list) { 61 count = snprintf(&modalias[len], size, "%s:", id->id); 62 if (count < 0 || count >= size) 63 return -EINVAL; 64 len += count; 65 size -= count; 66 } 67 68 modalias[len] = '\0'; 69 return len; 70 } 71 72 static ssize_t 73 acpi_device_modalias_show(struct device *dev, struct device_attribute *attr, char *buf) { 74 struct acpi_device *acpi_dev = to_acpi_device(dev); 75 int len; 76 77 /* Device has no HID and no CID or string is >1024 */ 78 len = create_modalias(acpi_dev, buf, 1024); 79 if (len <= 0) 80 return 0; 81 buf[len++] = '\n'; 82 return len; 83 } 84 static DEVICE_ATTR(modalias, 0444, acpi_device_modalias_show, NULL); 85 86 static void acpi_bus_hot_remove_device(void *context) 87 { 88 struct acpi_device *device; 89 acpi_handle handle = context; 90 struct acpi_object_list arg_list; 91 union acpi_object arg; 92 acpi_status status = AE_OK; 93 94 if (acpi_bus_get_device(handle, &device)) 95 return; 96 97 if (!device) 98 return; 99 100 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 101 "Hot-removing device %s...\n", dev_name(&device->dev))); 102 103 if (acpi_bus_trim(device, 1)) { 104 printk(KERN_ERR PREFIX 105 "Removing device failed\n"); 106 return; 107 } 108 109 /* power off device */ 110 status = acpi_evaluate_object(handle, "_PS3", NULL, NULL); 111 if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) 112 printk(KERN_WARNING PREFIX 113 "Power-off device failed\n"); 114 115 if (device->flags.lockable) { 116 arg_list.count = 1; 117 arg_list.pointer = &arg; 118 arg.type = ACPI_TYPE_INTEGER; 119 arg.integer.value = 0; 120 acpi_evaluate_object(handle, "_LCK", &arg_list, NULL); 121 } 122 123 arg_list.count = 1; 124 arg_list.pointer = &arg; 125 arg.type = ACPI_TYPE_INTEGER; 126 arg.integer.value = 1; 127 128 /* 129 * TBD: _EJD support. 130 */ 131 status = acpi_evaluate_object(handle, "_EJ0", &arg_list, NULL); 132 if (ACPI_FAILURE(status)) 133 printk(KERN_WARNING PREFIX 134 "Eject device failed\n"); 135 136 return; 137 } 138 139 static ssize_t 140 acpi_eject_store(struct device *d, struct device_attribute *attr, 141 const char *buf, size_t count) 142 { 143 int ret = count; 144 acpi_status status; 145 acpi_object_type type = 0; 146 struct acpi_device *acpi_device = to_acpi_device(d); 147 148 if ((!count) || (buf[0] != '1')) { 149 return -EINVAL; 150 } 151 #ifndef FORCE_EJECT 152 if (acpi_device->driver == NULL) { 153 ret = -ENODEV; 154 goto err; 155 } 156 #endif 157 status = acpi_get_type(acpi_device->handle, &type); 158 if (ACPI_FAILURE(status) || (!acpi_device->flags.ejectable)) { 159 ret = -ENODEV; 160 goto err; 161 } 162 163 acpi_os_hotplug_execute(acpi_bus_hot_remove_device, acpi_device->handle); 164 err: 165 return ret; 166 } 167 168 static DEVICE_ATTR(eject, 0200, NULL, acpi_eject_store); 169 170 static ssize_t 171 acpi_device_hid_show(struct device *dev, struct device_attribute *attr, char *buf) { 172 struct acpi_device *acpi_dev = to_acpi_device(dev); 173 174 return sprintf(buf, "%s\n", acpi_device_hid(acpi_dev)); 175 } 176 static DEVICE_ATTR(hid, 0444, acpi_device_hid_show, NULL); 177 178 static ssize_t 179 acpi_device_path_show(struct device *dev, struct device_attribute *attr, char *buf) { 180 struct acpi_device *acpi_dev = to_acpi_device(dev); 181 struct acpi_buffer path = {ACPI_ALLOCATE_BUFFER, NULL}; 182 int result; 183 184 result = acpi_get_name(acpi_dev->handle, ACPI_FULL_PATHNAME, &path); 185 if (result) 186 goto end; 187 188 result = sprintf(buf, "%s\n", (char*)path.pointer); 189 kfree(path.pointer); 190 end: 191 return result; 192 } 193 static DEVICE_ATTR(path, 0444, acpi_device_path_show, NULL); 194 195 static int acpi_device_setup_files(struct acpi_device *dev) 196 { 197 acpi_status status; 198 acpi_handle temp; 199 int result = 0; 200 201 /* 202 * Devices gotten from FADT don't have a "path" attribute 203 */ 204 if (dev->handle) { 205 result = device_create_file(&dev->dev, &dev_attr_path); 206 if (result) 207 goto end; 208 } 209 210 if (!list_empty(&dev->pnp.ids)) { 211 result = device_create_file(&dev->dev, &dev_attr_hid); 212 if (result) 213 goto end; 214 215 result = device_create_file(&dev->dev, &dev_attr_modalias); 216 if (result) 217 goto end; 218 } 219 220 /* 221 * If device has _EJ0, 'eject' file is created that is used to trigger 222 * hot-removal function from userland. 223 */ 224 status = acpi_get_handle(dev->handle, "_EJ0", &temp); 225 if (ACPI_SUCCESS(status)) 226 result = device_create_file(&dev->dev, &dev_attr_eject); 227 end: 228 return result; 229 } 230 231 static void acpi_device_remove_files(struct acpi_device *dev) 232 { 233 acpi_status status; 234 acpi_handle temp; 235 236 /* 237 * If device has _EJ0, 'eject' file is created that is used to trigger 238 * hot-removal function from userland. 239 */ 240 status = acpi_get_handle(dev->handle, "_EJ0", &temp); 241 if (ACPI_SUCCESS(status)) 242 device_remove_file(&dev->dev, &dev_attr_eject); 243 244 device_remove_file(&dev->dev, &dev_attr_modalias); 245 device_remove_file(&dev->dev, &dev_attr_hid); 246 if (dev->handle) 247 device_remove_file(&dev->dev, &dev_attr_path); 248 } 249 /* -------------------------------------------------------------------------- 250 ACPI Bus operations 251 -------------------------------------------------------------------------- */ 252 253 int acpi_match_device_ids(struct acpi_device *device, 254 const struct acpi_device_id *ids) 255 { 256 const struct acpi_device_id *id; 257 struct acpi_hardware_id *hwid; 258 259 /* 260 * If the device is not present, it is unnecessary to load device 261 * driver for it. 262 */ 263 if (!device->status.present) 264 return -ENODEV; 265 266 for (id = ids; id->id[0]; id++) 267 list_for_each_entry(hwid, &device->pnp.ids, list) 268 if (!strcmp((char *) id->id, hwid->id)) 269 return 0; 270 271 return -ENOENT; 272 } 273 EXPORT_SYMBOL(acpi_match_device_ids); 274 275 static void acpi_free_ids(struct acpi_device *device) 276 { 277 struct acpi_hardware_id *id, *tmp; 278 279 list_for_each_entry_safe(id, tmp, &device->pnp.ids, list) { 280 kfree(id->id); 281 kfree(id); 282 } 283 } 284 285 static void acpi_device_release(struct device *dev) 286 { 287 struct acpi_device *acpi_dev = to_acpi_device(dev); 288 289 acpi_free_ids(acpi_dev); 290 kfree(acpi_dev); 291 } 292 293 static int acpi_bus_match(struct device *dev, struct device_driver *drv) 294 { 295 struct acpi_device *acpi_dev = to_acpi_device(dev); 296 struct acpi_driver *acpi_drv = to_acpi_driver(drv); 297 298 return !acpi_match_device_ids(acpi_dev, acpi_drv->ids); 299 } 300 301 static int acpi_device_uevent(struct device *dev, struct kobj_uevent_env *env) 302 { 303 struct acpi_device *acpi_dev = to_acpi_device(dev); 304 int len; 305 306 if (list_empty(&acpi_dev->pnp.ids)) 307 return 0; 308 309 if (add_uevent_var(env, "MODALIAS=")) 310 return -ENOMEM; 311 len = create_modalias(acpi_dev, &env->buf[env->buflen - 1], 312 sizeof(env->buf) - env->buflen); 313 if (len >= (sizeof(env->buf) - env->buflen)) 314 return -ENOMEM; 315 env->buflen += len; 316 return 0; 317 } 318 319 static void acpi_device_notify(acpi_handle handle, u32 event, void *data) 320 { 321 struct acpi_device *device = data; 322 323 device->driver->ops.notify(device, event); 324 } 325 326 static acpi_status acpi_device_notify_fixed(void *data) 327 { 328 struct acpi_device *device = data; 329 330 /* Fixed hardware devices have no handles */ 331 acpi_device_notify(NULL, ACPI_FIXED_HARDWARE_EVENT, device); 332 return AE_OK; 333 } 334 335 static int acpi_device_install_notify_handler(struct acpi_device *device) 336 { 337 acpi_status status; 338 339 if (device->device_type == ACPI_BUS_TYPE_POWER_BUTTON) 340 status = 341 acpi_install_fixed_event_handler(ACPI_EVENT_POWER_BUTTON, 342 acpi_device_notify_fixed, 343 device); 344 else if (device->device_type == ACPI_BUS_TYPE_SLEEP_BUTTON) 345 status = 346 acpi_install_fixed_event_handler(ACPI_EVENT_SLEEP_BUTTON, 347 acpi_device_notify_fixed, 348 device); 349 else 350 status = acpi_install_notify_handler(device->handle, 351 ACPI_DEVICE_NOTIFY, 352 acpi_device_notify, 353 device); 354 355 if (ACPI_FAILURE(status)) 356 return -EINVAL; 357 return 0; 358 } 359 360 static void acpi_device_remove_notify_handler(struct acpi_device *device) 361 { 362 if (device->device_type == ACPI_BUS_TYPE_POWER_BUTTON) 363 acpi_remove_fixed_event_handler(ACPI_EVENT_POWER_BUTTON, 364 acpi_device_notify_fixed); 365 else if (device->device_type == ACPI_BUS_TYPE_SLEEP_BUTTON) 366 acpi_remove_fixed_event_handler(ACPI_EVENT_SLEEP_BUTTON, 367 acpi_device_notify_fixed); 368 else 369 acpi_remove_notify_handler(device->handle, ACPI_DEVICE_NOTIFY, 370 acpi_device_notify); 371 } 372 373 static int acpi_bus_driver_init(struct acpi_device *, struct acpi_driver *); 374 static int acpi_start_single_object(struct acpi_device *); 375 static int acpi_device_probe(struct device * dev) 376 { 377 struct acpi_device *acpi_dev = to_acpi_device(dev); 378 struct acpi_driver *acpi_drv = to_acpi_driver(dev->driver); 379 int ret; 380 381 ret = acpi_bus_driver_init(acpi_dev, acpi_drv); 382 if (!ret) { 383 if (acpi_dev->bus_ops.acpi_op_start) 384 acpi_start_single_object(acpi_dev); 385 386 if (acpi_drv->ops.notify) { 387 ret = acpi_device_install_notify_handler(acpi_dev); 388 if (ret) { 389 if (acpi_drv->ops.remove) 390 acpi_drv->ops.remove(acpi_dev, 391 acpi_dev->removal_type); 392 return ret; 393 } 394 } 395 396 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 397 "Found driver [%s] for device [%s]\n", 398 acpi_drv->name, acpi_dev->pnp.bus_id)); 399 get_device(dev); 400 } 401 return ret; 402 } 403 404 static int acpi_device_remove(struct device * dev) 405 { 406 struct acpi_device *acpi_dev = to_acpi_device(dev); 407 struct acpi_driver *acpi_drv = acpi_dev->driver; 408 409 if (acpi_drv) { 410 if (acpi_drv->ops.notify) 411 acpi_device_remove_notify_handler(acpi_dev); 412 if (acpi_drv->ops.remove) 413 acpi_drv->ops.remove(acpi_dev, acpi_dev->removal_type); 414 } 415 acpi_dev->driver = NULL; 416 acpi_dev->driver_data = NULL; 417 418 put_device(dev); 419 return 0; 420 } 421 422 struct bus_type acpi_bus_type = { 423 .name = "acpi", 424 .match = acpi_bus_match, 425 .probe = acpi_device_probe, 426 .remove = acpi_device_remove, 427 .uevent = acpi_device_uevent, 428 }; 429 430 static int acpi_device_register(struct acpi_device *device) 431 { 432 int result; 433 struct acpi_device_bus_id *acpi_device_bus_id, *new_bus_id; 434 int found = 0; 435 436 /* 437 * Linkage 438 * ------- 439 * Link this device to its parent and siblings. 440 */ 441 INIT_LIST_HEAD(&device->children); 442 INIT_LIST_HEAD(&device->node); 443 INIT_LIST_HEAD(&device->wakeup_list); 444 445 new_bus_id = kzalloc(sizeof(struct acpi_device_bus_id), GFP_KERNEL); 446 if (!new_bus_id) { 447 printk(KERN_ERR PREFIX "Memory allocation error\n"); 448 return -ENOMEM; 449 } 450 451 mutex_lock(&acpi_device_lock); 452 /* 453 * Find suitable bus_id and instance number in acpi_bus_id_list 454 * If failed, create one and link it into acpi_bus_id_list 455 */ 456 list_for_each_entry(acpi_device_bus_id, &acpi_bus_id_list, node) { 457 if (!strcmp(acpi_device_bus_id->bus_id, 458 acpi_device_hid(device))) { 459 acpi_device_bus_id->instance_no++; 460 found = 1; 461 kfree(new_bus_id); 462 break; 463 } 464 } 465 if (!found) { 466 acpi_device_bus_id = new_bus_id; 467 strcpy(acpi_device_bus_id->bus_id, acpi_device_hid(device)); 468 acpi_device_bus_id->instance_no = 0; 469 list_add_tail(&acpi_device_bus_id->node, &acpi_bus_id_list); 470 } 471 dev_set_name(&device->dev, "%s:%02x", acpi_device_bus_id->bus_id, acpi_device_bus_id->instance_no); 472 473 if (device->parent) 474 list_add_tail(&device->node, &device->parent->children); 475 476 if (device->wakeup.flags.valid) 477 list_add_tail(&device->wakeup_list, &acpi_wakeup_device_list); 478 mutex_unlock(&acpi_device_lock); 479 480 if (device->parent) 481 device->dev.parent = &device->parent->dev; 482 device->dev.bus = &acpi_bus_type; 483 device->dev.release = &acpi_device_release; 484 result = device_register(&device->dev); 485 if (result) { 486 dev_err(&device->dev, "Error registering device\n"); 487 goto end; 488 } 489 490 result = acpi_device_setup_files(device); 491 if (result) 492 printk(KERN_ERR PREFIX "Error creating sysfs interface for device %s\n", 493 dev_name(&device->dev)); 494 495 device->removal_type = ACPI_BUS_REMOVAL_NORMAL; 496 return 0; 497 end: 498 mutex_lock(&acpi_device_lock); 499 if (device->parent) 500 list_del(&device->node); 501 list_del(&device->wakeup_list); 502 mutex_unlock(&acpi_device_lock); 503 return result; 504 } 505 506 static void acpi_device_unregister(struct acpi_device *device, int type) 507 { 508 mutex_lock(&acpi_device_lock); 509 if (device->parent) 510 list_del(&device->node); 511 512 list_del(&device->wakeup_list); 513 mutex_unlock(&acpi_device_lock); 514 515 acpi_detach_data(device->handle, acpi_bus_data_handler); 516 517 acpi_device_remove_files(device); 518 device_unregister(&device->dev); 519 } 520 521 /* -------------------------------------------------------------------------- 522 Driver Management 523 -------------------------------------------------------------------------- */ 524 /** 525 * acpi_bus_driver_init - add a device to a driver 526 * @device: the device to add and initialize 527 * @driver: driver for the device 528 * 529 * Used to initialize a device via its device driver. Called whenever a 530 * driver is bound to a device. Invokes the driver's add() ops. 531 */ 532 static int 533 acpi_bus_driver_init(struct acpi_device *device, struct acpi_driver *driver) 534 { 535 int result = 0; 536 537 if (!device || !driver) 538 return -EINVAL; 539 540 if (!driver->ops.add) 541 return -ENOSYS; 542 543 result = driver->ops.add(device); 544 if (result) { 545 device->driver = NULL; 546 device->driver_data = NULL; 547 return result; 548 } 549 550 device->driver = driver; 551 552 /* 553 * TBD - Configuration Management: Assign resources to device based 554 * upon possible configuration and currently allocated resources. 555 */ 556 557 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 558 "Driver successfully bound to device\n")); 559 return 0; 560 } 561 562 static int acpi_start_single_object(struct acpi_device *device) 563 { 564 int result = 0; 565 struct acpi_driver *driver; 566 567 568 if (!(driver = device->driver)) 569 return 0; 570 571 if (driver->ops.start) { 572 result = driver->ops.start(device); 573 if (result && driver->ops.remove) 574 driver->ops.remove(device, ACPI_BUS_REMOVAL_NORMAL); 575 } 576 577 return result; 578 } 579 580 /** 581 * acpi_bus_register_driver - register a driver with the ACPI bus 582 * @driver: driver being registered 583 * 584 * Registers a driver with the ACPI bus. Searches the namespace for all 585 * devices that match the driver's criteria and binds. Returns zero for 586 * success or a negative error status for failure. 587 */ 588 int acpi_bus_register_driver(struct acpi_driver *driver) 589 { 590 int ret; 591 592 if (acpi_disabled) 593 return -ENODEV; 594 driver->drv.name = driver->name; 595 driver->drv.bus = &acpi_bus_type; 596 driver->drv.owner = driver->owner; 597 598 ret = driver_register(&driver->drv); 599 return ret; 600 } 601 602 EXPORT_SYMBOL(acpi_bus_register_driver); 603 604 /** 605 * acpi_bus_unregister_driver - unregisters a driver with the APIC bus 606 * @driver: driver to unregister 607 * 608 * Unregisters a driver with the ACPI bus. Searches the namespace for all 609 * devices that match the driver's criteria and unbinds. 610 */ 611 void acpi_bus_unregister_driver(struct acpi_driver *driver) 612 { 613 driver_unregister(&driver->drv); 614 } 615 616 EXPORT_SYMBOL(acpi_bus_unregister_driver); 617 618 /* -------------------------------------------------------------------------- 619 Device Enumeration 620 -------------------------------------------------------------------------- */ 621 static struct acpi_device *acpi_bus_get_parent(acpi_handle handle) 622 { 623 acpi_status status; 624 int ret; 625 struct acpi_device *device; 626 627 /* 628 * Fixed hardware devices do not appear in the namespace and do not 629 * have handles, but we fabricate acpi_devices for them, so we have 630 * to deal with them specially. 631 */ 632 if (handle == NULL) 633 return acpi_root; 634 635 do { 636 status = acpi_get_parent(handle, &handle); 637 if (status == AE_NULL_ENTRY) 638 return NULL; 639 if (ACPI_FAILURE(status)) 640 return acpi_root; 641 642 ret = acpi_bus_get_device(handle, &device); 643 if (ret == 0) 644 return device; 645 } while (1); 646 } 647 648 acpi_status 649 acpi_bus_get_ejd(acpi_handle handle, acpi_handle *ejd) 650 { 651 acpi_status status; 652 acpi_handle tmp; 653 struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER, NULL}; 654 union acpi_object *obj; 655 656 status = acpi_get_handle(handle, "_EJD", &tmp); 657 if (ACPI_FAILURE(status)) 658 return status; 659 660 status = acpi_evaluate_object(handle, "_EJD", NULL, &buffer); 661 if (ACPI_SUCCESS(status)) { 662 obj = buffer.pointer; 663 status = acpi_get_handle(ACPI_ROOT_OBJECT, obj->string.pointer, 664 ejd); 665 kfree(buffer.pointer); 666 } 667 return status; 668 } 669 EXPORT_SYMBOL_GPL(acpi_bus_get_ejd); 670 671 void acpi_bus_data_handler(acpi_handle handle, void *context) 672 { 673 674 /* TBD */ 675 676 return; 677 } 678 679 static int acpi_bus_get_perf_flags(struct acpi_device *device) 680 { 681 device->performance.state = ACPI_STATE_UNKNOWN; 682 return 0; 683 } 684 685 static acpi_status 686 acpi_bus_extract_wakeup_device_power_package(acpi_handle handle, 687 struct acpi_device_wakeup *wakeup) 688 { 689 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; 690 union acpi_object *package = NULL; 691 union acpi_object *element = NULL; 692 acpi_status status; 693 int i = 0; 694 695 if (!wakeup) 696 return AE_BAD_PARAMETER; 697 698 /* _PRW */ 699 status = acpi_evaluate_object(handle, "_PRW", NULL, &buffer); 700 if (ACPI_FAILURE(status)) { 701 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _PRW")); 702 return status; 703 } 704 705 package = (union acpi_object *)buffer.pointer; 706 707 if (!package || (package->package.count < 2)) { 708 status = AE_BAD_DATA; 709 goto out; 710 } 711 712 element = &(package->package.elements[0]); 713 if (!element) { 714 status = AE_BAD_DATA; 715 goto out; 716 } 717 if (element->type == ACPI_TYPE_PACKAGE) { 718 if ((element->package.count < 2) || 719 (element->package.elements[0].type != 720 ACPI_TYPE_LOCAL_REFERENCE) 721 || (element->package.elements[1].type != ACPI_TYPE_INTEGER)) { 722 status = AE_BAD_DATA; 723 goto out; 724 } 725 wakeup->gpe_device = 726 element->package.elements[0].reference.handle; 727 wakeup->gpe_number = 728 (u32) element->package.elements[1].integer.value; 729 } else if (element->type == ACPI_TYPE_INTEGER) { 730 wakeup->gpe_device = NULL; 731 wakeup->gpe_number = element->integer.value; 732 } else { 733 status = AE_BAD_DATA; 734 goto out; 735 } 736 737 element = &(package->package.elements[1]); 738 if (element->type != ACPI_TYPE_INTEGER) { 739 status = AE_BAD_DATA; 740 goto out; 741 } 742 wakeup->sleep_state = element->integer.value; 743 744 if ((package->package.count - 2) > ACPI_MAX_HANDLES) { 745 status = AE_NO_MEMORY; 746 goto out; 747 } 748 wakeup->resources.count = package->package.count - 2; 749 for (i = 0; i < wakeup->resources.count; i++) { 750 element = &(package->package.elements[i + 2]); 751 if (element->type != ACPI_TYPE_LOCAL_REFERENCE) { 752 status = AE_BAD_DATA; 753 goto out; 754 } 755 756 wakeup->resources.handles[i] = element->reference.handle; 757 } 758 759 acpi_setup_gpe_for_wake(handle, wakeup->gpe_device, wakeup->gpe_number); 760 761 out: 762 kfree(buffer.pointer); 763 764 return status; 765 } 766 767 static void acpi_bus_set_run_wake_flags(struct acpi_device *device) 768 { 769 struct acpi_device_id button_device_ids[] = { 770 {"PNP0C0D", 0}, 771 {"PNP0C0C", 0}, 772 {"PNP0C0E", 0}, 773 {"", 0}, 774 }; 775 acpi_status status; 776 acpi_event_status event_status; 777 778 device->wakeup.flags.notifier_present = 0; 779 780 /* Power button, Lid switch always enable wakeup */ 781 if (!acpi_match_device_ids(device, button_device_ids)) { 782 device->wakeup.flags.run_wake = 1; 783 device_set_wakeup_capable(&device->dev, true); 784 return; 785 } 786 787 status = acpi_get_gpe_status(device->wakeup.gpe_device, 788 device->wakeup.gpe_number, 789 &event_status); 790 if (status == AE_OK) 791 device->wakeup.flags.run_wake = 792 !!(event_status & ACPI_EVENT_FLAG_HANDLE); 793 } 794 795 static void acpi_bus_get_wakeup_device_flags(struct acpi_device *device) 796 { 797 acpi_handle temp; 798 acpi_status status = 0; 799 int psw_error; 800 801 /* Presence of _PRW indicates wake capable */ 802 status = acpi_get_handle(device->handle, "_PRW", &temp); 803 if (ACPI_FAILURE(status)) 804 return; 805 806 status = acpi_bus_extract_wakeup_device_power_package(device->handle, 807 &device->wakeup); 808 if (ACPI_FAILURE(status)) { 809 ACPI_EXCEPTION((AE_INFO, status, "Extracting _PRW package")); 810 return; 811 } 812 813 device->wakeup.flags.valid = 1; 814 device->wakeup.prepare_count = 0; 815 acpi_bus_set_run_wake_flags(device); 816 /* Call _PSW/_DSW object to disable its ability to wake the sleeping 817 * system for the ACPI device with the _PRW object. 818 * The _PSW object is depreciated in ACPI 3.0 and is replaced by _DSW. 819 * So it is necessary to call _DSW object first. Only when it is not 820 * present will the _PSW object used. 821 */ 822 psw_error = acpi_device_sleep_wake(device, 0, 0, 0); 823 if (psw_error) 824 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 825 "error in _DSW or _PSW evaluation\n")); 826 } 827 828 static void acpi_bus_add_power_resource(acpi_handle handle); 829 830 static int acpi_bus_get_power_flags(struct acpi_device *device) 831 { 832 acpi_status status = 0; 833 acpi_handle handle = NULL; 834 u32 i = 0; 835 836 837 /* 838 * Power Management Flags 839 */ 840 status = acpi_get_handle(device->handle, "_PSC", &handle); 841 if (ACPI_SUCCESS(status)) 842 device->power.flags.explicit_get = 1; 843 status = acpi_get_handle(device->handle, "_IRC", &handle); 844 if (ACPI_SUCCESS(status)) 845 device->power.flags.inrush_current = 1; 846 847 /* 848 * Enumerate supported power management states 849 */ 850 for (i = ACPI_STATE_D0; i <= ACPI_STATE_D3_HOT; i++) { 851 struct acpi_device_power_state *ps = &device->power.states[i]; 852 char object_name[5] = { '_', 'P', 'R', '0' + i, '\0' }; 853 854 /* Evaluate "_PRx" to se if power resources are referenced */ 855 acpi_evaluate_reference(device->handle, object_name, NULL, 856 &ps->resources); 857 if (ps->resources.count) { 858 int j; 859 860 device->power.flags.power_resources = 1; 861 for (j = 0; j < ps->resources.count; j++) 862 acpi_bus_add_power_resource(ps->resources.handles[j]); 863 } 864 865 /* Evaluate "_PSx" to see if we can do explicit sets */ 866 object_name[2] = 'S'; 867 status = acpi_get_handle(device->handle, object_name, &handle); 868 if (ACPI_SUCCESS(status)) 869 ps->flags.explicit_set = 1; 870 871 /* 872 * State is valid if there are means to put the device into it. 873 * D3hot is only valid if _PR3 present. 874 */ 875 if (ps->resources.count || 876 (ps->flags.explicit_set && i < ACPI_STATE_D3_HOT)) 877 ps->flags.valid = 1; 878 879 ps->power = -1; /* Unknown - driver assigned */ 880 ps->latency = -1; /* Unknown - driver assigned */ 881 } 882 883 /* Set defaults for D0 and D3 states (always valid) */ 884 device->power.states[ACPI_STATE_D0].flags.valid = 1; 885 device->power.states[ACPI_STATE_D0].power = 100; 886 device->power.states[ACPI_STATE_D3].flags.valid = 1; 887 device->power.states[ACPI_STATE_D3].power = 0; 888 889 /* Set D3cold's explicit_set flag if _PS3 exists. */ 890 if (device->power.states[ACPI_STATE_D3_HOT].flags.explicit_set) 891 device->power.states[ACPI_STATE_D3_COLD].flags.explicit_set = 1; 892 893 acpi_bus_init_power(device); 894 895 return 0; 896 } 897 898 static int acpi_bus_get_flags(struct acpi_device *device) 899 { 900 acpi_status status = AE_OK; 901 acpi_handle temp = NULL; 902 903 904 /* Presence of _STA indicates 'dynamic_status' */ 905 status = acpi_get_handle(device->handle, "_STA", &temp); 906 if (ACPI_SUCCESS(status)) 907 device->flags.dynamic_status = 1; 908 909 /* Presence of _RMV indicates 'removable' */ 910 status = acpi_get_handle(device->handle, "_RMV", &temp); 911 if (ACPI_SUCCESS(status)) 912 device->flags.removable = 1; 913 914 /* Presence of _EJD|_EJ0 indicates 'ejectable' */ 915 status = acpi_get_handle(device->handle, "_EJD", &temp); 916 if (ACPI_SUCCESS(status)) 917 device->flags.ejectable = 1; 918 else { 919 status = acpi_get_handle(device->handle, "_EJ0", &temp); 920 if (ACPI_SUCCESS(status)) 921 device->flags.ejectable = 1; 922 } 923 924 /* Presence of _LCK indicates 'lockable' */ 925 status = acpi_get_handle(device->handle, "_LCK", &temp); 926 if (ACPI_SUCCESS(status)) 927 device->flags.lockable = 1; 928 929 /* Power resources cannot be power manageable. */ 930 if (device->device_type == ACPI_BUS_TYPE_POWER) 931 return 0; 932 933 /* Presence of _PS0|_PR0 indicates 'power manageable' */ 934 status = acpi_get_handle(device->handle, "_PS0", &temp); 935 if (ACPI_FAILURE(status)) 936 status = acpi_get_handle(device->handle, "_PR0", &temp); 937 if (ACPI_SUCCESS(status)) 938 device->flags.power_manageable = 1; 939 940 /* TBD: Performance management */ 941 942 return 0; 943 } 944 945 static void acpi_device_get_busid(struct acpi_device *device) 946 { 947 char bus_id[5] = { '?', 0 }; 948 struct acpi_buffer buffer = { sizeof(bus_id), bus_id }; 949 int i = 0; 950 951 /* 952 * Bus ID 953 * ------ 954 * The device's Bus ID is simply the object name. 955 * TBD: Shouldn't this value be unique (within the ACPI namespace)? 956 */ 957 if (ACPI_IS_ROOT_DEVICE(device)) { 958 strcpy(device->pnp.bus_id, "ACPI"); 959 return; 960 } 961 962 switch (device->device_type) { 963 case ACPI_BUS_TYPE_POWER_BUTTON: 964 strcpy(device->pnp.bus_id, "PWRF"); 965 break; 966 case ACPI_BUS_TYPE_SLEEP_BUTTON: 967 strcpy(device->pnp.bus_id, "SLPF"); 968 break; 969 default: 970 acpi_get_name(device->handle, ACPI_SINGLE_NAME, &buffer); 971 /* Clean up trailing underscores (if any) */ 972 for (i = 3; i > 1; i--) { 973 if (bus_id[i] == '_') 974 bus_id[i] = '\0'; 975 else 976 break; 977 } 978 strcpy(device->pnp.bus_id, bus_id); 979 break; 980 } 981 } 982 983 /* 984 * acpi_bay_match - see if a device is an ejectable driver bay 985 * 986 * If an acpi object is ejectable and has one of the ACPI ATA methods defined, 987 * then we can safely call it an ejectable drive bay 988 */ 989 static int acpi_bay_match(struct acpi_device *device){ 990 acpi_status status; 991 acpi_handle handle; 992 acpi_handle tmp; 993 acpi_handle phandle; 994 995 handle = device->handle; 996 997 status = acpi_get_handle(handle, "_EJ0", &tmp); 998 if (ACPI_FAILURE(status)) 999 return -ENODEV; 1000 1001 if ((ACPI_SUCCESS(acpi_get_handle(handle, "_GTF", &tmp))) || 1002 (ACPI_SUCCESS(acpi_get_handle(handle, "_GTM", &tmp))) || 1003 (ACPI_SUCCESS(acpi_get_handle(handle, "_STM", &tmp))) || 1004 (ACPI_SUCCESS(acpi_get_handle(handle, "_SDD", &tmp)))) 1005 return 0; 1006 1007 if (acpi_get_parent(handle, &phandle)) 1008 return -ENODEV; 1009 1010 if ((ACPI_SUCCESS(acpi_get_handle(phandle, "_GTF", &tmp))) || 1011 (ACPI_SUCCESS(acpi_get_handle(phandle, "_GTM", &tmp))) || 1012 (ACPI_SUCCESS(acpi_get_handle(phandle, "_STM", &tmp))) || 1013 (ACPI_SUCCESS(acpi_get_handle(phandle, "_SDD", &tmp)))) 1014 return 0; 1015 1016 return -ENODEV; 1017 } 1018 1019 /* 1020 * acpi_dock_match - see if a device has a _DCK method 1021 */ 1022 static int acpi_dock_match(struct acpi_device *device) 1023 { 1024 acpi_handle tmp; 1025 return acpi_get_handle(device->handle, "_DCK", &tmp); 1026 } 1027 1028 const char *acpi_device_hid(struct acpi_device *device) 1029 { 1030 struct acpi_hardware_id *hid; 1031 1032 if (list_empty(&device->pnp.ids)) 1033 return dummy_hid; 1034 1035 hid = list_first_entry(&device->pnp.ids, struct acpi_hardware_id, list); 1036 return hid->id; 1037 } 1038 EXPORT_SYMBOL(acpi_device_hid); 1039 1040 static void acpi_add_id(struct acpi_device *device, const char *dev_id) 1041 { 1042 struct acpi_hardware_id *id; 1043 1044 id = kmalloc(sizeof(*id), GFP_KERNEL); 1045 if (!id) 1046 return; 1047 1048 id->id = kstrdup(dev_id, GFP_KERNEL); 1049 if (!id->id) { 1050 kfree(id); 1051 return; 1052 } 1053 1054 list_add_tail(&id->list, &device->pnp.ids); 1055 } 1056 1057 /* 1058 * Old IBM workstations have a DSDT bug wherein the SMBus object 1059 * lacks the SMBUS01 HID and the methods do not have the necessary "_" 1060 * prefix. Work around this. 1061 */ 1062 static int acpi_ibm_smbus_match(struct acpi_device *device) 1063 { 1064 acpi_handle h_dummy; 1065 struct acpi_buffer path = {ACPI_ALLOCATE_BUFFER, NULL}; 1066 int result; 1067 1068 if (!dmi_name_in_vendors("IBM")) 1069 return -ENODEV; 1070 1071 /* Look for SMBS object */ 1072 result = acpi_get_name(device->handle, ACPI_SINGLE_NAME, &path); 1073 if (result) 1074 return result; 1075 1076 if (strcmp("SMBS", path.pointer)) { 1077 result = -ENODEV; 1078 goto out; 1079 } 1080 1081 /* Does it have the necessary (but misnamed) methods? */ 1082 result = -ENODEV; 1083 if (ACPI_SUCCESS(acpi_get_handle(device->handle, "SBI", &h_dummy)) && 1084 ACPI_SUCCESS(acpi_get_handle(device->handle, "SBR", &h_dummy)) && 1085 ACPI_SUCCESS(acpi_get_handle(device->handle, "SBW", &h_dummy))) 1086 result = 0; 1087 out: 1088 kfree(path.pointer); 1089 return result; 1090 } 1091 1092 static void acpi_device_set_id(struct acpi_device *device) 1093 { 1094 acpi_status status; 1095 struct acpi_device_info *info; 1096 struct acpica_device_id_list *cid_list; 1097 int i; 1098 1099 switch (device->device_type) { 1100 case ACPI_BUS_TYPE_DEVICE: 1101 if (ACPI_IS_ROOT_DEVICE(device)) { 1102 acpi_add_id(device, ACPI_SYSTEM_HID); 1103 break; 1104 } 1105 1106 status = acpi_get_object_info(device->handle, &info); 1107 if (ACPI_FAILURE(status)) { 1108 printk(KERN_ERR PREFIX "%s: Error reading device info\n", __func__); 1109 return; 1110 } 1111 1112 if (info->valid & ACPI_VALID_HID) 1113 acpi_add_id(device, info->hardware_id.string); 1114 if (info->valid & ACPI_VALID_CID) { 1115 cid_list = &info->compatible_id_list; 1116 for (i = 0; i < cid_list->count; i++) 1117 acpi_add_id(device, cid_list->ids[i].string); 1118 } 1119 if (info->valid & ACPI_VALID_ADR) { 1120 device->pnp.bus_address = info->address; 1121 device->flags.bus_address = 1; 1122 } 1123 1124 kfree(info); 1125 1126 /* 1127 * Some devices don't reliably have _HIDs & _CIDs, so add 1128 * synthetic HIDs to make sure drivers can find them. 1129 */ 1130 if (acpi_is_video_device(device)) 1131 acpi_add_id(device, ACPI_VIDEO_HID); 1132 else if (ACPI_SUCCESS(acpi_bay_match(device))) 1133 acpi_add_id(device, ACPI_BAY_HID); 1134 else if (ACPI_SUCCESS(acpi_dock_match(device))) 1135 acpi_add_id(device, ACPI_DOCK_HID); 1136 else if (!acpi_ibm_smbus_match(device)) 1137 acpi_add_id(device, ACPI_SMBUS_IBM_HID); 1138 else if (!acpi_device_hid(device) && 1139 ACPI_IS_ROOT_DEVICE(device->parent)) { 1140 acpi_add_id(device, ACPI_BUS_HID); /* \_SB, LNXSYBUS */ 1141 strcpy(device->pnp.device_name, ACPI_BUS_DEVICE_NAME); 1142 strcpy(device->pnp.device_class, ACPI_BUS_CLASS); 1143 } 1144 1145 break; 1146 case ACPI_BUS_TYPE_POWER: 1147 acpi_add_id(device, ACPI_POWER_HID); 1148 break; 1149 case ACPI_BUS_TYPE_PROCESSOR: 1150 acpi_add_id(device, ACPI_PROCESSOR_OBJECT_HID); 1151 break; 1152 case ACPI_BUS_TYPE_THERMAL: 1153 acpi_add_id(device, ACPI_THERMAL_HID); 1154 break; 1155 case ACPI_BUS_TYPE_POWER_BUTTON: 1156 acpi_add_id(device, ACPI_BUTTON_HID_POWERF); 1157 break; 1158 case ACPI_BUS_TYPE_SLEEP_BUTTON: 1159 acpi_add_id(device, ACPI_BUTTON_HID_SLEEPF); 1160 break; 1161 } 1162 } 1163 1164 static int acpi_device_set_context(struct acpi_device *device) 1165 { 1166 acpi_status status; 1167 1168 /* 1169 * Context 1170 * ------- 1171 * Attach this 'struct acpi_device' to the ACPI object. This makes 1172 * resolutions from handle->device very efficient. Fixed hardware 1173 * devices have no handles, so we skip them. 1174 */ 1175 if (!device->handle) 1176 return 0; 1177 1178 status = acpi_attach_data(device->handle, 1179 acpi_bus_data_handler, device); 1180 if (ACPI_SUCCESS(status)) 1181 return 0; 1182 1183 printk(KERN_ERR PREFIX "Error attaching device data\n"); 1184 return -ENODEV; 1185 } 1186 1187 static int acpi_bus_remove(struct acpi_device *dev, int rmdevice) 1188 { 1189 if (!dev) 1190 return -EINVAL; 1191 1192 dev->removal_type = ACPI_BUS_REMOVAL_EJECT; 1193 device_release_driver(&dev->dev); 1194 1195 if (!rmdevice) 1196 return 0; 1197 1198 /* 1199 * unbind _ADR-Based Devices when hot removal 1200 */ 1201 if (dev->flags.bus_address) { 1202 if ((dev->parent) && (dev->parent->ops.unbind)) 1203 dev->parent->ops.unbind(dev); 1204 } 1205 acpi_device_unregister(dev, ACPI_BUS_REMOVAL_EJECT); 1206 1207 return 0; 1208 } 1209 1210 static int acpi_add_single_object(struct acpi_device **child, 1211 acpi_handle handle, int type, 1212 unsigned long long sta, 1213 struct acpi_bus_ops *ops) 1214 { 1215 int result; 1216 struct acpi_device *device; 1217 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; 1218 1219 device = kzalloc(sizeof(struct acpi_device), GFP_KERNEL); 1220 if (!device) { 1221 printk(KERN_ERR PREFIX "Memory allocation error\n"); 1222 return -ENOMEM; 1223 } 1224 1225 INIT_LIST_HEAD(&device->pnp.ids); 1226 device->device_type = type; 1227 device->handle = handle; 1228 device->parent = acpi_bus_get_parent(handle); 1229 device->bus_ops = *ops; /* workround for not call .start */ 1230 STRUCT_TO_INT(device->status) = sta; 1231 1232 acpi_device_get_busid(device); 1233 1234 /* 1235 * Flags 1236 * ----- 1237 * Note that we only look for object handles -- cannot evaluate objects 1238 * until we know the device is present and properly initialized. 1239 */ 1240 result = acpi_bus_get_flags(device); 1241 if (result) 1242 goto end; 1243 1244 /* 1245 * Initialize Device 1246 * ----------------- 1247 * TBD: Synch with Core's enumeration/initialization process. 1248 */ 1249 acpi_device_set_id(device); 1250 1251 /* 1252 * Power Management 1253 * ---------------- 1254 */ 1255 if (device->flags.power_manageable) { 1256 result = acpi_bus_get_power_flags(device); 1257 if (result) 1258 goto end; 1259 } 1260 1261 /* 1262 * Wakeup device management 1263 *----------------------- 1264 */ 1265 acpi_bus_get_wakeup_device_flags(device); 1266 1267 /* 1268 * Performance Management 1269 * ---------------------- 1270 */ 1271 if (device->flags.performance_manageable) { 1272 result = acpi_bus_get_perf_flags(device); 1273 if (result) 1274 goto end; 1275 } 1276 1277 if ((result = acpi_device_set_context(device))) 1278 goto end; 1279 1280 result = acpi_device_register(device); 1281 1282 /* 1283 * Bind _ADR-Based Devices when hot add 1284 */ 1285 if (device->flags.bus_address) { 1286 if (device->parent && device->parent->ops.bind) 1287 device->parent->ops.bind(device); 1288 } 1289 1290 end: 1291 if (!result) { 1292 acpi_get_name(handle, ACPI_FULL_PATHNAME, &buffer); 1293 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 1294 "Adding %s [%s] parent %s\n", dev_name(&device->dev), 1295 (char *) buffer.pointer, 1296 device->parent ? dev_name(&device->parent->dev) : 1297 "(null)")); 1298 kfree(buffer.pointer); 1299 *child = device; 1300 } else 1301 acpi_device_release(&device->dev); 1302 1303 return result; 1304 } 1305 1306 #define ACPI_STA_DEFAULT (ACPI_STA_DEVICE_PRESENT | ACPI_STA_DEVICE_ENABLED | \ 1307 ACPI_STA_DEVICE_UI | ACPI_STA_DEVICE_FUNCTIONING) 1308 1309 static void acpi_bus_add_power_resource(acpi_handle handle) 1310 { 1311 struct acpi_bus_ops ops = { 1312 .acpi_op_add = 1, 1313 .acpi_op_start = 1, 1314 }; 1315 struct acpi_device *device = NULL; 1316 1317 acpi_bus_get_device(handle, &device); 1318 if (!device) 1319 acpi_add_single_object(&device, handle, ACPI_BUS_TYPE_POWER, 1320 ACPI_STA_DEFAULT, &ops); 1321 } 1322 1323 static int acpi_bus_type_and_status(acpi_handle handle, int *type, 1324 unsigned long long *sta) 1325 { 1326 acpi_status status; 1327 acpi_object_type acpi_type; 1328 1329 status = acpi_get_type(handle, &acpi_type); 1330 if (ACPI_FAILURE(status)) 1331 return -ENODEV; 1332 1333 switch (acpi_type) { 1334 case ACPI_TYPE_ANY: /* for ACPI_ROOT_OBJECT */ 1335 case ACPI_TYPE_DEVICE: 1336 *type = ACPI_BUS_TYPE_DEVICE; 1337 status = acpi_bus_get_status_handle(handle, sta); 1338 if (ACPI_FAILURE(status)) 1339 return -ENODEV; 1340 break; 1341 case ACPI_TYPE_PROCESSOR: 1342 *type = ACPI_BUS_TYPE_PROCESSOR; 1343 status = acpi_bus_get_status_handle(handle, sta); 1344 if (ACPI_FAILURE(status)) 1345 return -ENODEV; 1346 break; 1347 case ACPI_TYPE_THERMAL: 1348 *type = ACPI_BUS_TYPE_THERMAL; 1349 *sta = ACPI_STA_DEFAULT; 1350 break; 1351 case ACPI_TYPE_POWER: 1352 *type = ACPI_BUS_TYPE_POWER; 1353 *sta = ACPI_STA_DEFAULT; 1354 break; 1355 default: 1356 return -ENODEV; 1357 } 1358 1359 return 0; 1360 } 1361 1362 static acpi_status acpi_bus_check_add(acpi_handle handle, u32 lvl, 1363 void *context, void **return_value) 1364 { 1365 struct acpi_bus_ops *ops = context; 1366 int type; 1367 unsigned long long sta; 1368 struct acpi_device *device; 1369 acpi_status status; 1370 int result; 1371 1372 result = acpi_bus_type_and_status(handle, &type, &sta); 1373 if (result) 1374 return AE_OK; 1375 1376 if (!(sta & ACPI_STA_DEVICE_PRESENT) && 1377 !(sta & ACPI_STA_DEVICE_FUNCTIONING)) { 1378 struct acpi_device_wakeup wakeup; 1379 acpi_handle temp; 1380 1381 status = acpi_get_handle(handle, "_PRW", &temp); 1382 if (ACPI_SUCCESS(status)) 1383 acpi_bus_extract_wakeup_device_power_package(handle, 1384 &wakeup); 1385 return AE_CTRL_DEPTH; 1386 } 1387 1388 /* 1389 * We may already have an acpi_device from a previous enumeration. If 1390 * so, we needn't add it again, but we may still have to start it. 1391 */ 1392 device = NULL; 1393 acpi_bus_get_device(handle, &device); 1394 if (ops->acpi_op_add && !device) 1395 acpi_add_single_object(&device, handle, type, sta, ops); 1396 1397 if (!device) 1398 return AE_CTRL_DEPTH; 1399 1400 if (ops->acpi_op_start && !(ops->acpi_op_add)) { 1401 status = acpi_start_single_object(device); 1402 if (ACPI_FAILURE(status)) 1403 return AE_CTRL_DEPTH; 1404 } 1405 1406 if (!*return_value) 1407 *return_value = device; 1408 return AE_OK; 1409 } 1410 1411 static int acpi_bus_scan(acpi_handle handle, struct acpi_bus_ops *ops, 1412 struct acpi_device **child) 1413 { 1414 acpi_status status; 1415 void *device = NULL; 1416 1417 status = acpi_bus_check_add(handle, 0, ops, &device); 1418 if (ACPI_SUCCESS(status)) 1419 acpi_walk_namespace(ACPI_TYPE_ANY, handle, ACPI_UINT32_MAX, 1420 acpi_bus_check_add, NULL, ops, &device); 1421 1422 if (child) 1423 *child = device; 1424 1425 if (device) 1426 return 0; 1427 else 1428 return -ENODEV; 1429 } 1430 1431 /* 1432 * acpi_bus_add and acpi_bus_start 1433 * 1434 * scan a given ACPI tree and (probably recently hot-plugged) 1435 * create and add or starts found devices. 1436 * 1437 * If no devices were found -ENODEV is returned which does not 1438 * mean that this is a real error, there just have been no suitable 1439 * ACPI objects in the table trunk from which the kernel could create 1440 * a device and add/start an appropriate driver. 1441 */ 1442 1443 int 1444 acpi_bus_add(struct acpi_device **child, 1445 struct acpi_device *parent, acpi_handle handle, int type) 1446 { 1447 struct acpi_bus_ops ops; 1448 1449 memset(&ops, 0, sizeof(ops)); 1450 ops.acpi_op_add = 1; 1451 1452 return acpi_bus_scan(handle, &ops, child); 1453 } 1454 EXPORT_SYMBOL(acpi_bus_add); 1455 1456 int acpi_bus_start(struct acpi_device *device) 1457 { 1458 struct acpi_bus_ops ops; 1459 int result; 1460 1461 if (!device) 1462 return -EINVAL; 1463 1464 memset(&ops, 0, sizeof(ops)); 1465 ops.acpi_op_start = 1; 1466 1467 result = acpi_bus_scan(device->handle, &ops, NULL); 1468 1469 acpi_update_all_gpes(); 1470 1471 return result; 1472 } 1473 EXPORT_SYMBOL(acpi_bus_start); 1474 1475 int acpi_bus_trim(struct acpi_device *start, int rmdevice) 1476 { 1477 acpi_status status; 1478 struct acpi_device *parent, *child; 1479 acpi_handle phandle, chandle; 1480 acpi_object_type type; 1481 u32 level = 1; 1482 int err = 0; 1483 1484 parent = start; 1485 phandle = start->handle; 1486 child = chandle = NULL; 1487 1488 while ((level > 0) && parent && (!err)) { 1489 status = acpi_get_next_object(ACPI_TYPE_ANY, phandle, 1490 chandle, &chandle); 1491 1492 /* 1493 * If this scope is exhausted then move our way back up. 1494 */ 1495 if (ACPI_FAILURE(status)) { 1496 level--; 1497 chandle = phandle; 1498 acpi_get_parent(phandle, &phandle); 1499 child = parent; 1500 parent = parent->parent; 1501 1502 if (level == 0) 1503 err = acpi_bus_remove(child, rmdevice); 1504 else 1505 err = acpi_bus_remove(child, 1); 1506 1507 continue; 1508 } 1509 1510 status = acpi_get_type(chandle, &type); 1511 if (ACPI_FAILURE(status)) { 1512 continue; 1513 } 1514 /* 1515 * If there is a device corresponding to chandle then 1516 * parse it (depth-first). 1517 */ 1518 if (acpi_bus_get_device(chandle, &child) == 0) { 1519 level++; 1520 phandle = chandle; 1521 chandle = NULL; 1522 parent = child; 1523 } 1524 continue; 1525 } 1526 return err; 1527 } 1528 EXPORT_SYMBOL_GPL(acpi_bus_trim); 1529 1530 static int acpi_bus_scan_fixed(void) 1531 { 1532 int result = 0; 1533 struct acpi_device *device = NULL; 1534 struct acpi_bus_ops ops; 1535 1536 memset(&ops, 0, sizeof(ops)); 1537 ops.acpi_op_add = 1; 1538 ops.acpi_op_start = 1; 1539 1540 /* 1541 * Enumerate all fixed-feature devices. 1542 */ 1543 if ((acpi_gbl_FADT.flags & ACPI_FADT_POWER_BUTTON) == 0) { 1544 result = acpi_add_single_object(&device, NULL, 1545 ACPI_BUS_TYPE_POWER_BUTTON, 1546 ACPI_STA_DEFAULT, 1547 &ops); 1548 device_init_wakeup(&device->dev, true); 1549 } 1550 1551 if ((acpi_gbl_FADT.flags & ACPI_FADT_SLEEP_BUTTON) == 0) { 1552 result = acpi_add_single_object(&device, NULL, 1553 ACPI_BUS_TYPE_SLEEP_BUTTON, 1554 ACPI_STA_DEFAULT, 1555 &ops); 1556 } 1557 1558 return result; 1559 } 1560 1561 int __init acpi_scan_init(void) 1562 { 1563 int result; 1564 struct acpi_bus_ops ops; 1565 1566 memset(&ops, 0, sizeof(ops)); 1567 ops.acpi_op_add = 1; 1568 ops.acpi_op_start = 1; 1569 1570 result = bus_register(&acpi_bus_type); 1571 if (result) { 1572 /* We don't want to quit even if we failed to add suspend/resume */ 1573 printk(KERN_ERR PREFIX "Could not register bus type\n"); 1574 } 1575 1576 acpi_power_init(); 1577 1578 /* 1579 * Enumerate devices in the ACPI namespace. 1580 */ 1581 result = acpi_bus_scan(ACPI_ROOT_OBJECT, &ops, &acpi_root); 1582 1583 if (!result) 1584 result = acpi_bus_scan_fixed(); 1585 1586 if (result) 1587 acpi_device_unregister(acpi_root, ACPI_BUS_REMOVAL_NORMAL); 1588 else 1589 acpi_update_all_gpes(); 1590 1591 return result; 1592 } 1593