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