1 /* 2 * drivers/acpi/power.c - ACPI Power Resources management. 3 * 4 * Copyright (C) 2001 - 2015 Intel Corp. 5 * Author: Andy Grover <andrew.grover@intel.com> 6 * Author: Paul Diefenbaugh <paul.s.diefenbaugh@intel.com> 7 * Author: Rafael J. Wysocki <rafael.j.wysocki@intel.com> 8 * 9 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 10 * 11 * This program is free software; you can redistribute it and/or modify 12 * it under the terms of the GNU General Public License as published by 13 * the Free Software Foundation; either version 2 of the License, or (at 14 * your option) any later version. 15 * 16 * This program is distributed in the hope that it will be useful, but 17 * WITHOUT ANY WARRANTY; without even the implied warranty of 18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 19 * General Public License for more details. 20 * 21 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 22 */ 23 24 /* 25 * ACPI power-managed devices may be controlled in two ways: 26 * 1. via "Device Specific (D-State) Control" 27 * 2. via "Power Resource Control". 28 * The code below deals with ACPI Power Resources control. 29 * 30 * An ACPI "power resource object" represents a software controllable power 31 * plane, clock plane, or other resource depended on by a device. 32 * 33 * A device may rely on multiple power resources, and a power resource 34 * may be shared by multiple devices. 35 */ 36 37 #include <linux/kernel.h> 38 #include <linux/module.h> 39 #include <linux/init.h> 40 #include <linux/types.h> 41 #include <linux/slab.h> 42 #include <linux/pm_runtime.h> 43 #include <linux/sysfs.h> 44 #include <linux/acpi.h> 45 #include "sleep.h" 46 #include "internal.h" 47 48 #define _COMPONENT ACPI_POWER_COMPONENT 49 ACPI_MODULE_NAME("power"); 50 #define ACPI_POWER_CLASS "power_resource" 51 #define ACPI_POWER_DEVICE_NAME "Power Resource" 52 #define ACPI_POWER_FILE_INFO "info" 53 #define ACPI_POWER_FILE_STATUS "state" 54 #define ACPI_POWER_RESOURCE_STATE_OFF 0x00 55 #define ACPI_POWER_RESOURCE_STATE_ON 0x01 56 #define ACPI_POWER_RESOURCE_STATE_UNKNOWN 0xFF 57 58 struct acpi_power_resource { 59 struct acpi_device device; 60 struct list_head list_node; 61 char *name; 62 u32 system_level; 63 u32 order; 64 unsigned int ref_count; 65 bool wakeup_enabled; 66 struct mutex resource_lock; 67 }; 68 69 struct acpi_power_resource_entry { 70 struct list_head node; 71 struct acpi_power_resource *resource; 72 }; 73 74 static LIST_HEAD(acpi_power_resource_list); 75 static DEFINE_MUTEX(power_resource_list_lock); 76 77 /* -------------------------------------------------------------------------- 78 Power Resource Management 79 -------------------------------------------------------------------------- */ 80 81 static inline 82 struct acpi_power_resource *to_power_resource(struct acpi_device *device) 83 { 84 return container_of(device, struct acpi_power_resource, device); 85 } 86 87 static struct acpi_power_resource *acpi_power_get_context(acpi_handle handle) 88 { 89 struct acpi_device *device; 90 91 if (acpi_bus_get_device(handle, &device)) 92 return NULL; 93 94 return to_power_resource(device); 95 } 96 97 static int acpi_power_resources_list_add(acpi_handle handle, 98 struct list_head *list) 99 { 100 struct acpi_power_resource *resource = acpi_power_get_context(handle); 101 struct acpi_power_resource_entry *entry; 102 103 if (!resource || !list) 104 return -EINVAL; 105 106 entry = kzalloc(sizeof(*entry), GFP_KERNEL); 107 if (!entry) 108 return -ENOMEM; 109 110 entry->resource = resource; 111 if (!list_empty(list)) { 112 struct acpi_power_resource_entry *e; 113 114 list_for_each_entry(e, list, node) 115 if (e->resource->order > resource->order) { 116 list_add_tail(&entry->node, &e->node); 117 return 0; 118 } 119 } 120 list_add_tail(&entry->node, list); 121 return 0; 122 } 123 124 void acpi_power_resources_list_free(struct list_head *list) 125 { 126 struct acpi_power_resource_entry *entry, *e; 127 128 list_for_each_entry_safe(entry, e, list, node) { 129 list_del(&entry->node); 130 kfree(entry); 131 } 132 } 133 134 static bool acpi_power_resource_is_dup(union acpi_object *package, 135 unsigned int start, unsigned int i) 136 { 137 acpi_handle rhandle, dup; 138 unsigned int j; 139 140 /* The caller is expected to check the package element types */ 141 rhandle = package->package.elements[i].reference.handle; 142 for (j = start; j < i; j++) { 143 dup = package->package.elements[j].reference.handle; 144 if (dup == rhandle) 145 return true; 146 } 147 148 return false; 149 } 150 151 int acpi_extract_power_resources(union acpi_object *package, unsigned int start, 152 struct list_head *list) 153 { 154 unsigned int i; 155 int err = 0; 156 157 for (i = start; i < package->package.count; i++) { 158 union acpi_object *element = &package->package.elements[i]; 159 acpi_handle rhandle; 160 161 if (element->type != ACPI_TYPE_LOCAL_REFERENCE) { 162 err = -ENODATA; 163 break; 164 } 165 rhandle = element->reference.handle; 166 if (!rhandle) { 167 err = -ENODEV; 168 break; 169 } 170 171 /* Some ACPI tables contain duplicate power resource references */ 172 if (acpi_power_resource_is_dup(package, start, i)) 173 continue; 174 175 err = acpi_add_power_resource(rhandle); 176 if (err) 177 break; 178 179 err = acpi_power_resources_list_add(rhandle, list); 180 if (err) 181 break; 182 } 183 if (err) 184 acpi_power_resources_list_free(list); 185 186 return err; 187 } 188 189 static int acpi_power_get_state(acpi_handle handle, int *state) 190 { 191 acpi_status status = AE_OK; 192 unsigned long long sta = 0; 193 char node_name[5]; 194 struct acpi_buffer buffer = { sizeof(node_name), node_name }; 195 196 197 if (!handle || !state) 198 return -EINVAL; 199 200 status = acpi_evaluate_integer(handle, "_STA", NULL, &sta); 201 if (ACPI_FAILURE(status)) 202 return -ENODEV; 203 204 *state = (sta & 0x01)?ACPI_POWER_RESOURCE_STATE_ON: 205 ACPI_POWER_RESOURCE_STATE_OFF; 206 207 acpi_get_name(handle, ACPI_SINGLE_NAME, &buffer); 208 209 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Resource [%s] is %s\n", 210 node_name, 211 *state ? "on" : "off")); 212 213 return 0; 214 } 215 216 static int acpi_power_get_list_state(struct list_head *list, int *state) 217 { 218 struct acpi_power_resource_entry *entry; 219 int cur_state; 220 221 if (!list || !state) 222 return -EINVAL; 223 224 /* The state of the list is 'on' IFF all resources are 'on'. */ 225 cur_state = 0; 226 list_for_each_entry(entry, list, node) { 227 struct acpi_power_resource *resource = entry->resource; 228 acpi_handle handle = resource->device.handle; 229 int result; 230 231 mutex_lock(&resource->resource_lock); 232 result = acpi_power_get_state(handle, &cur_state); 233 mutex_unlock(&resource->resource_lock); 234 if (result) 235 return result; 236 237 if (cur_state != ACPI_POWER_RESOURCE_STATE_ON) 238 break; 239 } 240 241 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Resource list is %s\n", 242 cur_state ? "on" : "off")); 243 244 *state = cur_state; 245 return 0; 246 } 247 248 static int __acpi_power_on(struct acpi_power_resource *resource) 249 { 250 acpi_status status = AE_OK; 251 252 status = acpi_evaluate_object(resource->device.handle, "_ON", NULL, NULL); 253 if (ACPI_FAILURE(status)) 254 return -ENODEV; 255 256 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Power resource [%s] turned on\n", 257 resource->name)); 258 259 return 0; 260 } 261 262 static int acpi_power_on_unlocked(struct acpi_power_resource *resource) 263 { 264 int result = 0; 265 266 if (resource->ref_count++) { 267 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 268 "Power resource [%s] already on\n", 269 resource->name)); 270 } else { 271 result = __acpi_power_on(resource); 272 if (result) 273 resource->ref_count--; 274 } 275 return result; 276 } 277 278 static int acpi_power_on(struct acpi_power_resource *resource) 279 { 280 int result; 281 282 mutex_lock(&resource->resource_lock); 283 result = acpi_power_on_unlocked(resource); 284 mutex_unlock(&resource->resource_lock); 285 return result; 286 } 287 288 static int __acpi_power_off(struct acpi_power_resource *resource) 289 { 290 acpi_status status; 291 292 status = acpi_evaluate_object(resource->device.handle, "_OFF", 293 NULL, NULL); 294 if (ACPI_FAILURE(status)) 295 return -ENODEV; 296 297 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Power resource [%s] turned off\n", 298 resource->name)); 299 return 0; 300 } 301 302 static int acpi_power_off_unlocked(struct acpi_power_resource *resource) 303 { 304 int result = 0; 305 306 if (!resource->ref_count) { 307 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 308 "Power resource [%s] already off\n", 309 resource->name)); 310 return 0; 311 } 312 313 if (--resource->ref_count) { 314 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 315 "Power resource [%s] still in use\n", 316 resource->name)); 317 } else { 318 result = __acpi_power_off(resource); 319 if (result) 320 resource->ref_count++; 321 } 322 return result; 323 } 324 325 static int acpi_power_off(struct acpi_power_resource *resource) 326 { 327 int result; 328 329 mutex_lock(&resource->resource_lock); 330 result = acpi_power_off_unlocked(resource); 331 mutex_unlock(&resource->resource_lock); 332 return result; 333 } 334 335 static int acpi_power_off_list(struct list_head *list) 336 { 337 struct acpi_power_resource_entry *entry; 338 int result = 0; 339 340 list_for_each_entry_reverse(entry, list, node) { 341 result = acpi_power_off(entry->resource); 342 if (result) 343 goto err; 344 } 345 return 0; 346 347 err: 348 list_for_each_entry_continue(entry, list, node) 349 acpi_power_on(entry->resource); 350 351 return result; 352 } 353 354 static int acpi_power_on_list(struct list_head *list) 355 { 356 struct acpi_power_resource_entry *entry; 357 int result = 0; 358 359 list_for_each_entry(entry, list, node) { 360 result = acpi_power_on(entry->resource); 361 if (result) 362 goto err; 363 } 364 return 0; 365 366 err: 367 list_for_each_entry_continue_reverse(entry, list, node) 368 acpi_power_off(entry->resource); 369 370 return result; 371 } 372 373 static struct attribute *attrs[] = { 374 NULL, 375 }; 376 377 static const struct attribute_group attr_groups[] = { 378 [ACPI_STATE_D0] = { 379 .name = "power_resources_D0", 380 .attrs = attrs, 381 }, 382 [ACPI_STATE_D1] = { 383 .name = "power_resources_D1", 384 .attrs = attrs, 385 }, 386 [ACPI_STATE_D2] = { 387 .name = "power_resources_D2", 388 .attrs = attrs, 389 }, 390 [ACPI_STATE_D3_HOT] = { 391 .name = "power_resources_D3hot", 392 .attrs = attrs, 393 }, 394 }; 395 396 static const struct attribute_group wakeup_attr_group = { 397 .name = "power_resources_wakeup", 398 .attrs = attrs, 399 }; 400 401 static void acpi_power_hide_list(struct acpi_device *adev, 402 struct list_head *resources, 403 const struct attribute_group *attr_group) 404 { 405 struct acpi_power_resource_entry *entry; 406 407 if (list_empty(resources)) 408 return; 409 410 list_for_each_entry_reverse(entry, resources, node) { 411 struct acpi_device *res_dev = &entry->resource->device; 412 413 sysfs_remove_link_from_group(&adev->dev.kobj, 414 attr_group->name, 415 dev_name(&res_dev->dev)); 416 } 417 sysfs_remove_group(&adev->dev.kobj, attr_group); 418 } 419 420 static void acpi_power_expose_list(struct acpi_device *adev, 421 struct list_head *resources, 422 const struct attribute_group *attr_group) 423 { 424 struct acpi_power_resource_entry *entry; 425 int ret; 426 427 if (list_empty(resources)) 428 return; 429 430 ret = sysfs_create_group(&adev->dev.kobj, attr_group); 431 if (ret) 432 return; 433 434 list_for_each_entry(entry, resources, node) { 435 struct acpi_device *res_dev = &entry->resource->device; 436 437 ret = sysfs_add_link_to_group(&adev->dev.kobj, 438 attr_group->name, 439 &res_dev->dev.kobj, 440 dev_name(&res_dev->dev)); 441 if (ret) { 442 acpi_power_hide_list(adev, resources, attr_group); 443 break; 444 } 445 } 446 } 447 448 static void acpi_power_expose_hide(struct acpi_device *adev, 449 struct list_head *resources, 450 const struct attribute_group *attr_group, 451 bool expose) 452 { 453 if (expose) 454 acpi_power_expose_list(adev, resources, attr_group); 455 else 456 acpi_power_hide_list(adev, resources, attr_group); 457 } 458 459 void acpi_power_add_remove_device(struct acpi_device *adev, bool add) 460 { 461 int state; 462 463 if (adev->wakeup.flags.valid) 464 acpi_power_expose_hide(adev, &adev->wakeup.resources, 465 &wakeup_attr_group, add); 466 467 if (!adev->power.flags.power_resources) 468 return; 469 470 for (state = ACPI_STATE_D0; state <= ACPI_STATE_D3_HOT; state++) 471 acpi_power_expose_hide(adev, 472 &adev->power.states[state].resources, 473 &attr_groups[state], add); 474 } 475 476 int acpi_power_wakeup_list_init(struct list_head *list, int *system_level_p) 477 { 478 struct acpi_power_resource_entry *entry; 479 int system_level = 5; 480 481 list_for_each_entry(entry, list, node) { 482 struct acpi_power_resource *resource = entry->resource; 483 acpi_handle handle = resource->device.handle; 484 int result; 485 int state; 486 487 mutex_lock(&resource->resource_lock); 488 489 result = acpi_power_get_state(handle, &state); 490 if (result) { 491 mutex_unlock(&resource->resource_lock); 492 return result; 493 } 494 if (state == ACPI_POWER_RESOURCE_STATE_ON) { 495 resource->ref_count++; 496 resource->wakeup_enabled = true; 497 } 498 if (system_level > resource->system_level) 499 system_level = resource->system_level; 500 501 mutex_unlock(&resource->resource_lock); 502 } 503 *system_level_p = system_level; 504 return 0; 505 } 506 507 /* -------------------------------------------------------------------------- 508 Device Power Management 509 -------------------------------------------------------------------------- */ 510 511 /** 512 * acpi_device_sleep_wake - execute _DSW (Device Sleep Wake) or (deprecated in 513 * ACPI 3.0) _PSW (Power State Wake) 514 * @dev: Device to handle. 515 * @enable: 0 - disable, 1 - enable the wake capabilities of the device. 516 * @sleep_state: Target sleep state of the system. 517 * @dev_state: Target power state of the device. 518 * 519 * Execute _DSW (Device Sleep Wake) or (deprecated in ACPI 3.0) _PSW (Power 520 * State Wake) for the device, if present. On failure reset the device's 521 * wakeup.flags.valid flag. 522 * 523 * RETURN VALUE: 524 * 0 if either _DSW or _PSW has been successfully executed 525 * 0 if neither _DSW nor _PSW has been found 526 * -ENODEV if the execution of either _DSW or _PSW has failed 527 */ 528 int acpi_device_sleep_wake(struct acpi_device *dev, 529 int enable, int sleep_state, int dev_state) 530 { 531 union acpi_object in_arg[3]; 532 struct acpi_object_list arg_list = { 3, in_arg }; 533 acpi_status status = AE_OK; 534 535 /* 536 * Try to execute _DSW first. 537 * 538 * Three agruments are needed for the _DSW object: 539 * Argument 0: enable/disable the wake capabilities 540 * Argument 1: target system state 541 * Argument 2: target device state 542 * When _DSW object is called to disable the wake capabilities, maybe 543 * the first argument is filled. The values of the other two agruments 544 * are meaningless. 545 */ 546 in_arg[0].type = ACPI_TYPE_INTEGER; 547 in_arg[0].integer.value = enable; 548 in_arg[1].type = ACPI_TYPE_INTEGER; 549 in_arg[1].integer.value = sleep_state; 550 in_arg[2].type = ACPI_TYPE_INTEGER; 551 in_arg[2].integer.value = dev_state; 552 status = acpi_evaluate_object(dev->handle, "_DSW", &arg_list, NULL); 553 if (ACPI_SUCCESS(status)) { 554 return 0; 555 } else if (status != AE_NOT_FOUND) { 556 printk(KERN_ERR PREFIX "_DSW execution failed\n"); 557 dev->wakeup.flags.valid = 0; 558 return -ENODEV; 559 } 560 561 /* Execute _PSW */ 562 status = acpi_execute_simple_method(dev->handle, "_PSW", enable); 563 if (ACPI_FAILURE(status) && (status != AE_NOT_FOUND)) { 564 printk(KERN_ERR PREFIX "_PSW execution failed\n"); 565 dev->wakeup.flags.valid = 0; 566 return -ENODEV; 567 } 568 569 return 0; 570 } 571 572 /* 573 * Prepare a wakeup device, two steps (Ref ACPI 2.0:P229): 574 * 1. Power on the power resources required for the wakeup device 575 * 2. Execute _DSW (Device Sleep Wake) or (deprecated in ACPI 3.0) _PSW (Power 576 * State Wake) for the device, if present 577 */ 578 int acpi_enable_wakeup_device_power(struct acpi_device *dev, int sleep_state) 579 { 580 struct acpi_power_resource_entry *entry; 581 int err = 0; 582 583 if (!dev || !dev->wakeup.flags.valid) 584 return -EINVAL; 585 586 mutex_lock(&acpi_device_lock); 587 588 if (dev->wakeup.prepare_count++) 589 goto out; 590 591 list_for_each_entry(entry, &dev->wakeup.resources, node) { 592 struct acpi_power_resource *resource = entry->resource; 593 594 mutex_lock(&resource->resource_lock); 595 596 if (!resource->wakeup_enabled) { 597 err = acpi_power_on_unlocked(resource); 598 if (!err) 599 resource->wakeup_enabled = true; 600 } 601 602 mutex_unlock(&resource->resource_lock); 603 604 if (err) { 605 dev_err(&dev->dev, 606 "Cannot turn wakeup power resources on\n"); 607 dev->wakeup.flags.valid = 0; 608 goto out; 609 } 610 } 611 /* 612 * Passing 3 as the third argument below means the device may be 613 * put into arbitrary power state afterward. 614 */ 615 err = acpi_device_sleep_wake(dev, 1, sleep_state, 3); 616 if (err) 617 dev->wakeup.prepare_count = 0; 618 619 out: 620 mutex_unlock(&acpi_device_lock); 621 return err; 622 } 623 624 /* 625 * Shutdown a wakeup device, counterpart of above method 626 * 1. Execute _DSW (Device Sleep Wake) or (deprecated in ACPI 3.0) _PSW (Power 627 * State Wake) for the device, if present 628 * 2. Shutdown down the power resources 629 */ 630 int acpi_disable_wakeup_device_power(struct acpi_device *dev) 631 { 632 struct acpi_power_resource_entry *entry; 633 int err = 0; 634 635 if (!dev || !dev->wakeup.flags.valid) 636 return -EINVAL; 637 638 mutex_lock(&acpi_device_lock); 639 640 if (--dev->wakeup.prepare_count > 0) 641 goto out; 642 643 /* 644 * Executing the code below even if prepare_count is already zero when 645 * the function is called may be useful, for example for initialisation. 646 */ 647 if (dev->wakeup.prepare_count < 0) 648 dev->wakeup.prepare_count = 0; 649 650 err = acpi_device_sleep_wake(dev, 0, 0, 0); 651 if (err) 652 goto out; 653 654 list_for_each_entry(entry, &dev->wakeup.resources, node) { 655 struct acpi_power_resource *resource = entry->resource; 656 657 mutex_lock(&resource->resource_lock); 658 659 if (resource->wakeup_enabled) { 660 err = acpi_power_off_unlocked(resource); 661 if (!err) 662 resource->wakeup_enabled = false; 663 } 664 665 mutex_unlock(&resource->resource_lock); 666 667 if (err) { 668 dev_err(&dev->dev, 669 "Cannot turn wakeup power resources off\n"); 670 dev->wakeup.flags.valid = 0; 671 break; 672 } 673 } 674 675 out: 676 mutex_unlock(&acpi_device_lock); 677 return err; 678 } 679 680 int acpi_power_get_inferred_state(struct acpi_device *device, int *state) 681 { 682 int result = 0; 683 int list_state = 0; 684 int i = 0; 685 686 if (!device || !state) 687 return -EINVAL; 688 689 /* 690 * We know a device's inferred power state when all the resources 691 * required for a given D-state are 'on'. 692 */ 693 for (i = ACPI_STATE_D0; i <= ACPI_STATE_D3_HOT; i++) { 694 struct list_head *list = &device->power.states[i].resources; 695 696 if (list_empty(list)) 697 continue; 698 699 result = acpi_power_get_list_state(list, &list_state); 700 if (result) 701 return result; 702 703 if (list_state == ACPI_POWER_RESOURCE_STATE_ON) { 704 *state = i; 705 return 0; 706 } 707 } 708 709 *state = device->power.states[ACPI_STATE_D3_COLD].flags.valid ? 710 ACPI_STATE_D3_COLD : ACPI_STATE_D3_HOT; 711 return 0; 712 } 713 714 int acpi_power_on_resources(struct acpi_device *device, int state) 715 { 716 if (!device || state < ACPI_STATE_D0 || state > ACPI_STATE_D3_HOT) 717 return -EINVAL; 718 719 return acpi_power_on_list(&device->power.states[state].resources); 720 } 721 722 int acpi_power_transition(struct acpi_device *device, int state) 723 { 724 int result = 0; 725 726 if (!device || (state < ACPI_STATE_D0) || (state > ACPI_STATE_D3_COLD)) 727 return -EINVAL; 728 729 if (device->power.state == state || !device->flags.power_manageable) 730 return 0; 731 732 if ((device->power.state < ACPI_STATE_D0) 733 || (device->power.state > ACPI_STATE_D3_COLD)) 734 return -ENODEV; 735 736 /* 737 * First we reference all power resources required in the target list 738 * (e.g. so the device doesn't lose power while transitioning). Then, 739 * we dereference all power resources used in the current list. 740 */ 741 if (state < ACPI_STATE_D3_COLD) 742 result = acpi_power_on_list( 743 &device->power.states[state].resources); 744 745 if (!result && device->power.state < ACPI_STATE_D3_COLD) 746 acpi_power_off_list( 747 &device->power.states[device->power.state].resources); 748 749 /* We shouldn't change the state unless the above operations succeed. */ 750 device->power.state = result ? ACPI_STATE_UNKNOWN : state; 751 752 return result; 753 } 754 755 static void acpi_release_power_resource(struct device *dev) 756 { 757 struct acpi_device *device = to_acpi_device(dev); 758 struct acpi_power_resource *resource; 759 760 resource = container_of(device, struct acpi_power_resource, device); 761 762 mutex_lock(&power_resource_list_lock); 763 list_del(&resource->list_node); 764 mutex_unlock(&power_resource_list_lock); 765 766 acpi_free_pnp_ids(&device->pnp); 767 kfree(resource); 768 } 769 770 static ssize_t acpi_power_in_use_show(struct device *dev, 771 struct device_attribute *attr, 772 char *buf) { 773 struct acpi_power_resource *resource; 774 775 resource = to_power_resource(to_acpi_device(dev)); 776 return sprintf(buf, "%u\n", !!resource->ref_count); 777 } 778 static DEVICE_ATTR(resource_in_use, 0444, acpi_power_in_use_show, NULL); 779 780 static void acpi_power_sysfs_remove(struct acpi_device *device) 781 { 782 device_remove_file(&device->dev, &dev_attr_resource_in_use); 783 } 784 785 static void acpi_power_add_resource_to_list(struct acpi_power_resource *resource) 786 { 787 mutex_lock(&power_resource_list_lock); 788 789 if (!list_empty(&acpi_power_resource_list)) { 790 struct acpi_power_resource *r; 791 792 list_for_each_entry(r, &acpi_power_resource_list, list_node) 793 if (r->order > resource->order) { 794 list_add_tail(&resource->list_node, &r->list_node); 795 goto out; 796 } 797 } 798 list_add_tail(&resource->list_node, &acpi_power_resource_list); 799 800 out: 801 mutex_unlock(&power_resource_list_lock); 802 } 803 804 int acpi_add_power_resource(acpi_handle handle) 805 { 806 struct acpi_power_resource *resource; 807 struct acpi_device *device = NULL; 808 union acpi_object acpi_object; 809 struct acpi_buffer buffer = { sizeof(acpi_object), &acpi_object }; 810 acpi_status status; 811 int state, result = -ENODEV; 812 813 acpi_bus_get_device(handle, &device); 814 if (device) 815 return 0; 816 817 resource = kzalloc(sizeof(*resource), GFP_KERNEL); 818 if (!resource) 819 return -ENOMEM; 820 821 device = &resource->device; 822 acpi_init_device_object(device, handle, ACPI_BUS_TYPE_POWER, 823 ACPI_STA_DEFAULT); 824 mutex_init(&resource->resource_lock); 825 INIT_LIST_HEAD(&resource->list_node); 826 resource->name = device->pnp.bus_id; 827 strcpy(acpi_device_name(device), ACPI_POWER_DEVICE_NAME); 828 strcpy(acpi_device_class(device), ACPI_POWER_CLASS); 829 device->power.state = ACPI_STATE_UNKNOWN; 830 831 /* Evalute the object to get the system level and resource order. */ 832 status = acpi_evaluate_object(handle, NULL, NULL, &buffer); 833 if (ACPI_FAILURE(status)) 834 goto err; 835 836 resource->system_level = acpi_object.power_resource.system_level; 837 resource->order = acpi_object.power_resource.resource_order; 838 839 result = acpi_power_get_state(handle, &state); 840 if (result) 841 goto err; 842 843 printk(KERN_INFO PREFIX "%s [%s] (%s)\n", acpi_device_name(device), 844 acpi_device_bid(device), state ? "on" : "off"); 845 846 device->flags.match_driver = true; 847 result = acpi_device_add(device, acpi_release_power_resource); 848 if (result) 849 goto err; 850 851 if (!device_create_file(&device->dev, &dev_attr_resource_in_use)) 852 device->remove = acpi_power_sysfs_remove; 853 854 acpi_power_add_resource_to_list(resource); 855 acpi_device_add_finalize(device); 856 return 0; 857 858 err: 859 acpi_release_power_resource(&device->dev); 860 return result; 861 } 862 863 #ifdef CONFIG_ACPI_SLEEP 864 void acpi_resume_power_resources(void) 865 { 866 struct acpi_power_resource *resource; 867 868 mutex_lock(&power_resource_list_lock); 869 870 list_for_each_entry(resource, &acpi_power_resource_list, list_node) { 871 int result, state; 872 873 mutex_lock(&resource->resource_lock); 874 875 result = acpi_power_get_state(resource->device.handle, &state); 876 if (result) { 877 mutex_unlock(&resource->resource_lock); 878 continue; 879 } 880 881 if (state == ACPI_POWER_RESOURCE_STATE_OFF 882 && resource->ref_count) { 883 dev_info(&resource->device.dev, "Turning ON\n"); 884 __acpi_power_on(resource); 885 } 886 887 mutex_unlock(&resource->resource_lock); 888 } 889 890 mutex_unlock(&power_resource_list_lock); 891 } 892 893 void acpi_turn_off_unused_power_resources(void) 894 { 895 struct acpi_power_resource *resource; 896 897 mutex_lock(&power_resource_list_lock); 898 899 list_for_each_entry_reverse(resource, &acpi_power_resource_list, list_node) { 900 int result, state; 901 902 mutex_lock(&resource->resource_lock); 903 904 result = acpi_power_get_state(resource->device.handle, &state); 905 if (result) { 906 mutex_unlock(&resource->resource_lock); 907 continue; 908 } 909 910 if (state == ACPI_POWER_RESOURCE_STATE_ON 911 && !resource->ref_count) { 912 dev_info(&resource->device.dev, "Turning OFF\n"); 913 __acpi_power_off(resource); 914 } 915 916 mutex_unlock(&resource->resource_lock); 917 } 918 919 mutex_unlock(&power_resource_list_lock); 920 } 921 #endif 922