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