drivers/acpi/power.c

   1 /*
   2  *  acpi_power.c - ACPI Bus Power Management ($Revision: 39 $)
   3  *
   4  *  Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
   5  *  Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
   6  *
   7  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   8  *
   9  *  This program is free software; you can redistribute it and/or modify
  10  *  it under the terms of the GNU General Public License as published by
  11  *  the Free Software Foundation; either version 2 of the License, or (at
  12  *  your option) any later version.
  13  *
  14  *  This program is distributed in the hope that it will be useful, but
  15  *  WITHOUT ANY WARRANTY; without even the implied warranty of
  16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  *  General Public License for more details.
  18  *
  19  *  You should have received a copy of the GNU General Public License along
  20  *  with this program; if not, write to the Free Software Foundation, Inc.,
  21  *  59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
  22  *
  23  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  24  */
  25
  26 /*
  27  * ACPI power-managed devices may be controlled in two ways:
  28  * 1. via "Device Specific (D-State) Control"
  29  * 2. via "Power Resource Control".
  30  * This module is used to manage devices relying on Power Resource Control.
  31  *
  32  * An ACPI "power resource object" describes a software controllable power
  33  * plane, clock plane, or other resource used by a power managed device.
  34  * A device may rely on multiple power resources, and a power resource
  35  * may be shared by multiple devices.
  36  */
  37
  38 #include <linux/kernel.h>
  39 #include <linux/module.h>
  40 #include <linux/init.h>
  41 #include <linux/types.h>
  42 #include <linux/slab.h>
  43 #include <linux/proc_fs.h>
  44 #include <linux/seq_file.h>
  45 #include <acpi/acpi_bus.h>
  46 #include <acpi/acpi_drivers.h>
  47 #include "sleep.h"
  48
  49 #define PREFIX "ACPI: "
  50
  51 #define _COMPONENT                      ACPI_POWER_COMPONENT
  52 ACPI_MODULE_NAME("power");
  53 #define ACPI_POWER_CLASS                "power_resource"
  54 #define ACPI_POWER_DEVICE_NAME          "Power Resource"
  55 #define ACPI_POWER_FILE_INFO            "info"
  56 #define ACPI_POWER_FILE_STATUS          "state"
  57 #define ACPI_POWER_RESOURCE_STATE_OFF   0x00
  58 #define ACPI_POWER_RESOURCE_STATE_ON    0x01
  59 #define ACPI_POWER_RESOURCE_STATE_UNKNOWN 0xFF
  60
  61 int acpi_power_nocheck;
  62 module_param_named(power_nocheck, acpi_power_nocheck, bool, 000);
  63
  64 static int acpi_power_add(struct acpi_device *device);
  65 static int acpi_power_remove(struct acpi_device *device, int type);
  66 static int acpi_power_resume(struct acpi_device *device);
  67 static int acpi_power_open_fs(struct inode *inode, struct file *file);
  68
  69 static const struct acpi_device_id power_device_ids[] = {
  70         {ACPI_POWER_HID, 0},
  71         {"", 0},
  72 };
  73 MODULE_DEVICE_TABLE(acpi, power_device_ids);
  74
  75 static struct acpi_driver acpi_power_driver = {
  76         .name = "power",
  77         .class = ACPI_POWER_CLASS,
  78         .ids = power_device_ids,
  79         .ops = {
  80                 .add = acpi_power_add,
  81                 .remove = acpi_power_remove,
  82                 .resume = acpi_power_resume,
  83                 },
  84 };
  85
  86 struct acpi_power_reference {
  87         struct list_head node;
  88         struct acpi_device *device;
  89 };
  90
  91 struct acpi_power_resource {
  92         struct acpi_device * device;
  93         acpi_bus_id name;
  94         u32 system_level;
  95         u32 order;
  96         struct mutex resource_lock;
  97         struct list_head reference;
  98 };
  99
 100 static struct list_head acpi_power_resource_list;
 101
 102 static const struct file_operations acpi_power_fops = {
 103         .owner = THIS_MODULE,
 104         .open = acpi_power_open_fs,
 105         .read = seq_read,
 106         .llseek = seq_lseek,
 107         .release = single_release,
 108 };
 109
 110 /* --------------------------------------------------------------------------
 111                              Power Resource Management
 112    -------------------------------------------------------------------------- */
 113
 114 static int
 115 acpi_power_get_context(acpi_handle handle,
 116                        struct acpi_power_resource **resource)
 117 {
 118         int result = 0;
 119         struct acpi_device *device = NULL;
 120
 121
 122         if (!resource)
 123                 return -ENODEV;
 124
 125         result = acpi_bus_get_device(handle, &device);
 126         if (result) {
 127                 printk(KERN_WARNING PREFIX "Getting context [%p]\n", handle);
 128                 return result;
 129         }
 130
 131         *resource = acpi_driver_data(device);
 132         if (!*resource)
 133                 return -ENODEV;
 134
 135         return 0;
 136 }
 137
 138 static int acpi_power_get_state(acpi_handle handle, int *state)
 139 {
 140         acpi_status status = AE_OK;
 141         unsigned long long sta = 0;
 142         char node_name[5];
 143         struct acpi_buffer buffer = { sizeof(node_name), node_name };
 144
 145
 146         if (!handle || !state)
 147                 return -EINVAL;
 148
 149         status = acpi_evaluate_integer(handle, "_STA", NULL, &sta);
 150         if (ACPI_FAILURE(status))
 151                 return -ENODEV;
 152
 153         *state = (sta & 0x01)?ACPI_POWER_RESOURCE_STATE_ON:
 154                               ACPI_POWER_RESOURCE_STATE_OFF;
 155
 156         acpi_get_name(handle, ACPI_SINGLE_NAME, &buffer);
 157
 158         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Resource [%s] is %s\n",
 159                           node_name,
 160                                 *state ? "on" : "off"));
 161
 162         return 0;
 163 }
 164
 165 static int acpi_power_get_list_state(struct acpi_handle_list *list, int *state)
 166 {
 167         int result = 0, state1;
 168         u32 i = 0;
 169
 170
 171         if (!list || !state)
 172                 return -EINVAL;
 173
 174         /* The state of the list is 'on' IFF all resources are 'on'. */
 175         /* */
 176
 177         for (i = 0; i < list->count; i++) {
 178                 /*
 179                  * The state of the power resource can be obtained by
 180                  * using the ACPI handle. In such case it is unnecessary to
 181                  * get the Power resource first and then get its state again.
 182                  */
 183                 result = acpi_power_get_state(list->handles[i], &state1);
 184                 if (result)
 185                         return result;
 186
 187                 *state = state1;
 188
 189                 if (*state != ACPI_POWER_RESOURCE_STATE_ON)
 190                         break;
 191         }
 192
 193         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Resource list is %s\n",
 194                           *state ? "on" : "off"));
 195
 196         return result;
 197 }
 198
 199 static int acpi_power_on(acpi_handle handle, struct acpi_device *dev)
 200 {
 201         int result = 0;
 202         int found = 0;
 203         acpi_status status = AE_OK;
 204         struct acpi_power_resource *resource = NULL;
 205         struct list_head *node, *next;
 206         struct acpi_power_reference *ref;
 207
 208
 209         result = acpi_power_get_context(handle, &resource);
 210         if (result)
 211                 return result;
 212
 213         mutex_lock(&resource->resource_lock);
 214         list_for_each_safe(node, next, &resource->reference) {
 215                 ref = container_of(node, struct acpi_power_reference, node);
 216                 if (dev->handle == ref->device->handle) {
 217                         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device [%s] already referenced by resource [%s]\n",
 218                                   dev->pnp.bus_id, resource->name));
 219                         found = 1;
 220                         break;
 221                 }
 222         }
 223
 224         if (!found) {
 225                 ref = kmalloc(sizeof (struct acpi_power_reference),
 226                     irqs_disabled() ? GFP_ATOMIC : GFP_KERNEL);
 227                 if (!ref) {
 228                         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "kmalloc() failed\n"));
 229                         mutex_unlock(&resource->resource_lock);
 230                         return -ENOMEM;
 231                 }
 232                 list_add_tail(&ref->node, &resource->reference);
 233                 ref->device = dev;
 234                 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device [%s] added to resource [%s] references\n",
 235                           dev->pnp.bus_id, resource->name));
 236         }
 237         mutex_unlock(&resource->resource_lock);
 238
 239         status = acpi_evaluate_object(resource->device->handle, "_ON", NULL, NULL);
 240         if (ACPI_FAILURE(status))
 241                 return -ENODEV;
 242
 243         /* Update the power resource's _device_ power state */
 244         resource->device->power.state = ACPI_STATE_D0;
 245
 246         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Resource [%s] turned on\n",
 247                           resource->name));
 248         return 0;
 249 }
 250
 251 static int acpi_power_off_device(acpi_handle handle, struct acpi_device *dev)
 252 {
 253         int result = 0;
 254         acpi_status status = AE_OK;
 255         struct acpi_power_resource *resource = NULL;
 256         struct list_head *node, *next;
 257         struct acpi_power_reference *ref;
 258
 259
 260         result = acpi_power_get_context(handle, &resource);
 261         if (result)
 262                 return result;
 263
 264         mutex_lock(&resource->resource_lock);
 265         list_for_each_safe(node, next, &resource->reference) {
 266                 ref = container_of(node, struct acpi_power_reference, node);
 267                 if (dev->handle == ref->device->handle) {
 268                         list_del(&ref->node);
 269                         kfree(ref);
 270                         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device [%s] removed from resource [%s] references\n",
 271                             dev->pnp.bus_id, resource->name));
 272                         break;
 273                 }
 274         }
 275
 276         if (!list_empty(&resource->reference)) {
 277                 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Cannot turn resource [%s] off - resource is in use\n",
 278                     resource->name));
 279                 mutex_unlock(&resource->resource_lock);
 280                 return 0;
 281         }
 282         mutex_unlock(&resource->resource_lock);
 283
 284         status = acpi_evaluate_object(resource->device->handle, "_OFF", NULL, NULL);
 285         if (ACPI_FAILURE(status))
 286                 return -ENODEV;
 287
 288         /* Update the power resource's _device_ power state */
 289         resource->device->power.state = ACPI_STATE_D3;
 290
 291         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Resource [%s] turned off\n",
 292                           resource->name));
 293
 294         return 0;
 295 }
 296
 297 /**
 298  * acpi_device_sleep_wake - execute _DSW (Device Sleep Wake) or (deprecated in
 299  *                          ACPI 3.0) _PSW (Power State Wake)
 300  * @dev: Device to handle.
 301  * @enable: 0 - disable, 1 - enable the wake capabilities of the device.
 302  * @sleep_state: Target sleep state of the system.
 303  * @dev_state: Target power state of the device.
 304  *
 305  * Execute _DSW (Device Sleep Wake) or (deprecated in ACPI 3.0) _PSW (Power
 306  * State Wake) for the device, if present.  On failure reset the device's
 307  * wakeup.flags.valid flag.
 308  *
 309  * RETURN VALUE:
 310  * 0 if either _DSW or _PSW has been successfully executed
 311  * 0 if neither _DSW nor _PSW has been found
 312  * -ENODEV if the execution of either _DSW or _PSW has failed
 313  */
 314 int acpi_device_sleep_wake(struct acpi_device *dev,
 315                            int enable, int sleep_state, int dev_state)
 316 {
 317         union acpi_object in_arg[3];
 318         struct acpi_object_list arg_list = { 3, in_arg };
 319         acpi_status status = AE_OK;
 320
 321         /*
 322          * Try to execute _DSW first.
 323          *
 324          * Three agruments are needed for the _DSW object:
 325          * Argument 0: enable/disable the wake capabilities
 326          * Argument 1: target system state
 327          * Argument 2: target device state
 328          * When _DSW object is called to disable the wake capabilities, maybe
 329          * the first argument is filled. The values of the other two agruments
 330          * are meaningless.
 331          */
 332         in_arg[0].type = ACPI_TYPE_INTEGER;
 333         in_arg[0].integer.value = enable;
 334         in_arg[1].type = ACPI_TYPE_INTEGER;
 335         in_arg[1].integer.value = sleep_state;
 336         in_arg[2].type = ACPI_TYPE_INTEGER;
 337         in_arg[2].integer.value = dev_state;
 338         status = acpi_evaluate_object(dev->handle, "_DSW", &arg_list, NULL);
 339         if (ACPI_SUCCESS(status)) {
 340                 return 0;
 341         } else if (status != AE_NOT_FOUND) {
 342                 printk(KERN_ERR PREFIX "_DSW execution failed\n");
 343                 dev->wakeup.flags.valid = 0;
 344                 return -ENODEV;
 345         }
 346
 347         /* Execute _PSW */
 348         arg_list.count = 1;
 349         in_arg[0].integer.value = enable;
 350         status = acpi_evaluate_object(dev->handle, "_PSW", &arg_list, NULL);
 351         if (ACPI_FAILURE(status) && (status != AE_NOT_FOUND)) {
 352                 printk(KERN_ERR PREFIX "_PSW execution failed\n");
 353                 dev->wakeup.flags.valid = 0;
 354                 return -ENODEV;
 355         }
 356
 357         return 0;
 358 }
 359
 360 /*
 361  * Prepare a wakeup device, two steps (Ref ACPI 2.0:P229):
 362  * 1. Power on the power resources required for the wakeup device
 363  * 2. Execute _DSW (Device Sleep Wake) or (deprecated in ACPI 3.0) _PSW (Power
 364  *    State Wake) for the device, if present
 365  */
 366 int acpi_enable_wakeup_device_power(struct acpi_device *dev, int sleep_state)
 367 {
 368         int i, err = 0;
 369
 370         if (!dev || !dev->wakeup.flags.valid)
 371                 return -EINVAL;
 372
 373         mutex_lock(&acpi_device_lock);
 374
 375         if (dev->wakeup.prepare_count++)
 376                 goto out;
 377
 378         /* Open power resource */
 379         for (i = 0; i < dev->wakeup.resources.count; i++) {
 380                 int ret = acpi_power_on(dev->wakeup.resources.handles[i], dev);
 381                 if (ret) {
 382                         printk(KERN_ERR PREFIX "Transition power state\n");
 383                         dev->wakeup.flags.valid = 0;
 384                         err = -ENODEV;
 385                         goto err_out;
 386                 }
 387         }
 388
 389         /*
 390          * Passing 3 as the third argument below means the device may be placed
 391          * in arbitrary power state afterwards.
 392          */
 393         err = acpi_device_sleep_wake(dev, 1, sleep_state, 3);
 394
 395  err_out:
 396         if (err)
 397                 dev->wakeup.prepare_count = 0;
 398
 399  out:
 400         mutex_unlock(&acpi_device_lock);
 401         return err;
 402 }
 403
 404 /*
 405  * Shutdown a wakeup device, counterpart of above method
 406  * 1. Execute _DSW (Device Sleep Wake) or (deprecated in ACPI 3.0) _PSW (Power
 407  *    State Wake) for the device, if present
 408  * 2. Shutdown down the power resources
 409  */
 410 int acpi_disable_wakeup_device_power(struct acpi_device *dev)
 411 {
 412         int i, err = 0;
 413
 414         if (!dev || !dev->wakeup.flags.valid)
 415                 return -EINVAL;
 416
 417         mutex_lock(&acpi_device_lock);
 418
 419         if (--dev->wakeup.prepare_count > 0)
 420                 goto out;
 421
 422         /*
 423          * Executing the code below even if prepare_count is already zero when
 424          * the function is called may be useful, for example for initialisation.
 425          */
 426         if (dev->wakeup.prepare_count < 0)
 427                 dev->wakeup.prepare_count = 0;
 428
 429         err = acpi_device_sleep_wake(dev, 0, 0, 0);
 430         if (err)
 431                 goto out;
 432
 433         /* Close power resource */
 434         for (i = 0; i < dev->wakeup.resources.count; i++) {
 435                 int ret = acpi_power_off_device(
 436                                 dev->wakeup.resources.handles[i], dev);
 437                 if (ret) {
 438                         printk(KERN_ERR PREFIX "Transition power state\n");
 439                         dev->wakeup.flags.valid = 0;
 440                         err = -ENODEV;
 441                         goto out;
 442                 }
 443         }
 444
 445  out:
 446         mutex_unlock(&acpi_device_lock);
 447         return err;
 448 }
 449
 450 /* --------------------------------------------------------------------------
 451                              Device Power Management
 452    -------------------------------------------------------------------------- */
 453
 454 int acpi_power_get_inferred_state(struct acpi_device *device)
 455 {
 456         int result = 0;
 457         struct acpi_handle_list *list = NULL;
 458         int list_state = 0;
 459         int i = 0;
 460
 461
 462         if (!device)
 463                 return -EINVAL;
 464
 465         device->power.state = ACPI_STATE_UNKNOWN;
 466
 467         /*
 468          * We know a device's inferred power state when all the resources
 469          * required for a given D-state are 'on'.
 470          */
 471         for (i = ACPI_STATE_D0; i < ACPI_STATE_D3; i++) {
 472                 list = &device->power.states[i].resources;
 473                 if (list->count < 1)
 474                         continue;
 475
 476                 result = acpi_power_get_list_state(list, &list_state);
 477                 if (result)
 478                         return result;
 479
 480                 if (list_state == ACPI_POWER_RESOURCE_STATE_ON) {
 481                         device->power.state = i;
 482                         return 0;
 483                 }
 484         }
 485
 486         device->power.state = ACPI_STATE_D3;
 487
 488         return 0;
 489 }
 490
 491 int acpi_power_transition(struct acpi_device *device, int state)
 492 {
 493         int result = 0;
 494         struct acpi_handle_list *cl = NULL;     /* Current Resources */
 495         struct acpi_handle_list *tl = NULL;     /* Target Resources */
 496         int i = 0;
 497
 498
 499         if (!device || (state < ACPI_STATE_D0) || (state > ACPI_STATE_D3))
 500                 return -EINVAL;
 501
 502         if ((device->power.state < ACPI_STATE_D0)
 503             || (device->power.state > ACPI_STATE_D3))
 504                 return -ENODEV;
 505
 506         cl = &device->power.states[device->power.state].resources;
 507         tl = &device->power.states[state].resources;
 508
 509         /* TBD: Resources must be ordered. */
 510
 511         /*
 512          * First we reference all power resources required in the target list
 513          * (e.g. so the device doesn't lose power while transitioning).
 514          */
 515         for (i = 0; i < tl->count; i++) {
 516                 result = acpi_power_on(tl->handles[i], device);
 517                 if (result)
 518                         goto end;
 519         }
 520
 521         if (device->power.state == state) {
 522                 goto end;
 523         }
 524
 525         /*
 526          * Then we dereference all power resources used in the current list.
 527          */
 528         for (i = 0; i < cl->count; i++) {
 529                 result = acpi_power_off_device(cl->handles[i], device);
 530                 if (result)
 531                         goto end;
 532         }
 533
 534      end:
 535         if (result)
 536                 device->power.state = ACPI_STATE_UNKNOWN;
 537         else {
 538         /* We shouldn't change the state till all above operations succeed */
 539                 device->power.state = state;
 540         }
 541
 542         return result;
 543 }
 544
 545 /* --------------------------------------------------------------------------
 546                               FS Interface (/proc)
 547    -------------------------------------------------------------------------- */
 548
 549 static struct proc_dir_entry *acpi_power_dir;
 550
 551 static int acpi_power_seq_show(struct seq_file *seq, void *offset)
 552 {
 553         int count = 0;
 554         int result = 0, state;
 555         struct acpi_power_resource *resource = NULL;
 556         struct list_head *node, *next;
 557         struct acpi_power_reference *ref;
 558
 559
 560         resource = seq->private;
 561
 562         if (!resource)
 563                 goto end;
 564
 565         result = acpi_power_get_state(resource->device->handle, &state);
 566         if (result)
 567                 goto end;
 568
 569         seq_puts(seq, "state:                   ");
 570         switch (state) {
 571         case ACPI_POWER_RESOURCE_STATE_ON:
 572                 seq_puts(seq, "on\n");
 573                 break;
 574         case ACPI_POWER_RESOURCE_STATE_OFF:
 575                 seq_puts(seq, "off\n");
 576                 break;
 577         default:
 578                 seq_puts(seq, "unknown\n");
 579                 break;
 580         }
 581
 582         mutex_lock(&resource->resource_lock);
 583         list_for_each_safe(node, next, &resource->reference) {
 584                 ref = container_of(node, struct acpi_power_reference, node);
 585                 count++;
 586         }
 587         mutex_unlock(&resource->resource_lock);
 588
 589         seq_printf(seq, "system level:            S%d\n"
 590                    "order:                   %d\n"
 591                    "reference count:         %d\n",
 592                    resource->system_level,
 593                    resource->order, count);
 594
 595       end:
 596         return 0;
 597 }
 598
 599 static int acpi_power_open_fs(struct inode *inode, struct file *file)
 600 {
 601         return single_open(file, acpi_power_seq_show, PDE(inode)->data);
 602 }
 603
 604 static int acpi_power_add_fs(struct acpi_device *device)
 605 {
 606         struct proc_dir_entry *entry = NULL;
 607
 608
 609         if (!device)
 610                 return -EINVAL;
 611
 612         if (!acpi_device_dir(device)) {
 613                 acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device),
 614                                                      acpi_power_dir);
 615                 if (!acpi_device_dir(device))
 616                         return -ENODEV;
 617         }
 618
 619         /* 'status' [R] */
 620         entry = proc_create_data(ACPI_POWER_FILE_STATUS,
 621                                  S_IRUGO, acpi_device_dir(device),
 622                                  &acpi_power_fops, acpi_driver_data(device));
 623         if (!entry)
 624                 return -EIO;
 625         return 0;
 626 }
 627
 628 static int acpi_power_remove_fs(struct acpi_device *device)
 629 {
 630
 631         if (acpi_device_dir(device)) {
 632                 remove_proc_entry(ACPI_POWER_FILE_STATUS,
 633                                   acpi_device_dir(device));
 634                 remove_proc_entry(acpi_device_bid(device), acpi_power_dir);
 635                 acpi_device_dir(device) = NULL;
 636         }
 637
 638         return 0;
 639 }
 640
 641 /* --------------------------------------------------------------------------
 642                                 Driver Interface
 643    -------------------------------------------------------------------------- */
 644
 645 static int acpi_power_add(struct acpi_device *device)
 646 {
 647         int result = 0, state;
 648         acpi_status status = AE_OK;
 649         struct acpi_power_resource *resource = NULL;
 650         union acpi_object acpi_object;
 651         struct acpi_buffer buffer = { sizeof(acpi_object), &acpi_object };
 652
 653
 654         if (!device)
 655                 return -EINVAL;
 656
 657         resource = kzalloc(sizeof(struct acpi_power_resource), GFP_KERNEL);
 658         if (!resource)
 659                 return -ENOMEM;
 660
 661         resource->device = device;
 662         mutex_init(&resource->resource_lock);
 663         INIT_LIST_HEAD(&resource->reference);
 664         strcpy(resource->name, device->pnp.bus_id);
 665         strcpy(acpi_device_name(device), ACPI_POWER_DEVICE_NAME);
 666         strcpy(acpi_device_class(device), ACPI_POWER_CLASS);
 667         device->driver_data = resource;
 668
 669         /* Evalute the object to get the system level and resource order. */
 670         status = acpi_evaluate_object(device->handle, NULL, NULL, &buffer);
 671         if (ACPI_FAILURE(status)) {
 672                 result = -ENODEV;
 673                 goto end;
 674         }
 675         resource->system_level = acpi_object.power_resource.system_level;
 676         resource->order = acpi_object.power_resource.resource_order;
 677
 678         result = acpi_power_get_state(device->handle, &state);
 679         if (result)
 680                 goto end;
 681
 682         switch (state) {
 683         case ACPI_POWER_RESOURCE_STATE_ON:
 684                 device->power.state = ACPI_STATE_D0;
 685                 break;
 686         case ACPI_POWER_RESOURCE_STATE_OFF:
 687                 device->power.state = ACPI_STATE_D3;
 688                 break;
 689         default:
 690                 device->power.state = ACPI_STATE_UNKNOWN;
 691                 break;
 692         }
 693
 694         result = acpi_power_add_fs(device);
 695         if (result)
 696                 goto end;
 697
 698         printk(KERN_INFO PREFIX "%s [%s] (%s)\n", acpi_device_name(device),
 699                acpi_device_bid(device), state ? "on" : "off");
 700
 701       end:
 702         if (result)
 703                 kfree(resource);
 704
 705         return result;
 706 }
 707
 708 static int acpi_power_remove(struct acpi_device *device, int type)
 709 {
 710         struct acpi_power_resource *resource = NULL;
 711         struct list_head *node, *next;
 712
 713
 714         if (!device || !acpi_driver_data(device))
 715                 return -EINVAL;
 716
 717         resource = acpi_driver_data(device);
 718
 719         acpi_power_remove_fs(device);
 720
 721         mutex_lock(&resource->resource_lock);
 722         list_for_each_safe(node, next, &resource->reference) {
 723                 struct acpi_power_reference *ref = container_of(node, struct acpi_power_reference, node);
 724                 list_del(&ref->node);
 725                 kfree(ref);
 726         }
 727         mutex_unlock(&resource->resource_lock);
 728
 729         kfree(resource);
 730
 731         return 0;
 732 }
 733
 734 static int acpi_power_resume(struct acpi_device *device)
 735 {
 736         int result = 0, state;
 737         struct acpi_power_resource *resource = NULL;
 738         struct acpi_power_reference *ref;
 739
 740         if (!device || !acpi_driver_data(device))
 741                 return -EINVAL;
 742
 743         resource = acpi_driver_data(device);
 744
 745         result = acpi_power_get_state(device->handle, &state);
 746         if (result)
 747                 return result;
 748
 749         mutex_lock(&resource->resource_lock);
 750         if (state == ACPI_POWER_RESOURCE_STATE_OFF &&
 751             !list_empty(&resource->reference)) {
 752                 ref = container_of(resource->reference.next, struct acpi_power_reference, node);
 753                 mutex_unlock(&resource->resource_lock);
 754                 result = acpi_power_on(device->handle, ref->device);
 755                 return result;
 756         }
 757
 758         mutex_unlock(&resource->resource_lock);
 759         return 0;
 760 }
 761
 762 int __init acpi_power_init(void)
 763 {
 764         int result = 0;
 765
 766         INIT_LIST_HEAD(&acpi_power_resource_list);
 767
 768         acpi_power_dir = proc_mkdir(ACPI_POWER_CLASS, acpi_root_dir);
 769         if (!acpi_power_dir)
 770                 return -ENODEV;
 771
 772         result = acpi_bus_register_driver(&acpi_power_driver);
 773         if (result < 0) {
 774                 remove_proc_entry(ACPI_POWER_CLASS, acpi_root_dir);
 775                 return -ENODEV;
 776         }
 777
 778         return 0;
 779 }