drivers/acpi/power.c

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