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