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