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