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