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