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