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