]> git.kernelconcepts.de Git - karo-tx-linux.git/blob - drivers/acpi/power.c
Merge tag 'md-3.6-fixes' of git://neil.brown.name/md
[karo-tx-linux.git] / 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/pm_runtime.h>
44 #include <acpi/acpi_bus.h>
45 #include <acpi/acpi_drivers.h>
46 #include "sleep.h"
47 #include "internal.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 static int acpi_power_add(struct acpi_device *device);
62 static int acpi_power_remove(struct acpi_device *device, int type);
63
64 static const struct acpi_device_id power_device_ids[] = {
65         {ACPI_POWER_HID, 0},
66         {"", 0},
67 };
68 MODULE_DEVICE_TABLE(acpi, power_device_ids);
69
70 #ifdef CONFIG_PM_SLEEP
71 static int acpi_power_resume(struct device *dev);
72 #endif
73 static SIMPLE_DEV_PM_OPS(acpi_power_pm, NULL, acpi_power_resume);
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                 },
83         .drv.pm = &acpi_power_pm,
84 };
85
86 /*
87  * A power managed device
88  * A device may rely on multiple power resources.
89  * */
90 struct acpi_power_managed_device {
91         struct device *dev; /* The physical device */
92         acpi_handle *handle;
93 };
94
95 struct acpi_power_resource_device {
96         struct acpi_power_managed_device *device;
97         struct acpi_power_resource_device *next;
98 };
99
100 struct acpi_power_resource {
101         struct acpi_device * device;
102         acpi_bus_id name;
103         u32 system_level;
104         u32 order;
105         unsigned int ref_count;
106         struct mutex resource_lock;
107
108         /* List of devices relying on this power resource */
109         struct acpi_power_resource_device *devices;
110 };
111
112 static struct list_head acpi_power_resource_list;
113
114 /* --------------------------------------------------------------------------
115                              Power Resource Management
116    -------------------------------------------------------------------------- */
117
118 static int
119 acpi_power_get_context(acpi_handle handle,
120                        struct acpi_power_resource **resource)
121 {
122         int result = 0;
123         struct acpi_device *device = NULL;
124
125
126         if (!resource)
127                 return -ENODEV;
128
129         result = acpi_bus_get_device(handle, &device);
130         if (result) {
131                 printk(KERN_WARNING PREFIX "Getting context [%p]\n", handle);
132                 return result;
133         }
134
135         *resource = acpi_driver_data(device);
136         if (!*resource)
137                 return -ENODEV;
138
139         return 0;
140 }
141
142 static int acpi_power_get_state(acpi_handle handle, int *state)
143 {
144         acpi_status status = AE_OK;
145         unsigned long long sta = 0;
146         char node_name[5];
147         struct acpi_buffer buffer = { sizeof(node_name), node_name };
148
149
150         if (!handle || !state)
151                 return -EINVAL;
152
153         status = acpi_evaluate_integer(handle, "_STA", NULL, &sta);
154         if (ACPI_FAILURE(status))
155                 return -ENODEV;
156
157         *state = (sta & 0x01)?ACPI_POWER_RESOURCE_STATE_ON:
158                               ACPI_POWER_RESOURCE_STATE_OFF;
159
160         acpi_get_name(handle, ACPI_SINGLE_NAME, &buffer);
161
162         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Resource [%s] is %s\n",
163                           node_name,
164                                 *state ? "on" : "off"));
165
166         return 0;
167 }
168
169 static int acpi_power_get_list_state(struct acpi_handle_list *list, int *state)
170 {
171         int cur_state;
172         int i = 0;
173
174         if (!list || !state)
175                 return -EINVAL;
176
177         /* The state of the list is 'on' IFF all resources are 'on'. */
178
179         for (i = 0; i < list->count; i++) {
180                 struct acpi_power_resource *resource;
181                 acpi_handle handle = list->handles[i];
182                 int result;
183
184                 result = acpi_power_get_context(handle, &resource);
185                 if (result)
186                         return result;
187
188                 mutex_lock(&resource->resource_lock);
189
190                 result = acpi_power_get_state(handle, &cur_state);
191
192                 mutex_unlock(&resource->resource_lock);
193
194                 if (result)
195                         return result;
196
197                 if (cur_state != ACPI_POWER_RESOURCE_STATE_ON)
198                         break;
199         }
200
201         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Resource list is %s\n",
202                           cur_state ? "on" : "off"));
203
204         *state = cur_state;
205
206         return 0;
207 }
208
209 /* Resume the device when all power resources in _PR0 are on */
210 static void acpi_power_on_device(struct acpi_power_managed_device *device)
211 {
212         struct acpi_device *acpi_dev;
213         acpi_handle handle = device->handle;
214         int state;
215
216         if (acpi_bus_get_device(handle, &acpi_dev))
217                 return;
218
219         if(acpi_power_get_inferred_state(acpi_dev, &state))
220                 return;
221
222         if (state == ACPI_STATE_D0 && pm_runtime_suspended(device->dev))
223                 pm_request_resume(device->dev);
224 }
225
226 static int __acpi_power_on(struct acpi_power_resource *resource)
227 {
228         struct acpi_power_resource_device *device_list = resource->devices;
229         acpi_status status = AE_OK;
230
231         status = acpi_evaluate_object(resource->device->handle, "_ON", NULL, NULL);
232         if (ACPI_FAILURE(status))
233                 return -ENODEV;
234
235         /* Update the power resource's _device_ power state */
236         resource->device->power.state = ACPI_STATE_D0;
237
238         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Power resource [%s] turned on\n",
239                           resource->name));
240
241         while (device_list) {
242                 acpi_power_on_device(device_list->device);
243
244                 device_list = device_list->next;
245         }
246
247         return 0;
248 }
249
250 static int acpi_power_on(acpi_handle handle)
251 {
252         int result = 0;
253         struct acpi_power_resource *resource = NULL;
254
255         result = acpi_power_get_context(handle, &resource);
256         if (result)
257                 return result;
258
259         mutex_lock(&resource->resource_lock);
260
261         if (resource->ref_count++) {
262                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
263                                   "Power resource [%s] already on",
264                                   resource->name));
265         } else {
266                 result = __acpi_power_on(resource);
267                 if (result)
268                         resource->ref_count--;
269         }
270
271         mutex_unlock(&resource->resource_lock);
272
273         return result;
274 }
275
276 static int acpi_power_off(acpi_handle handle)
277 {
278         int result = 0;
279         acpi_status status = AE_OK;
280         struct acpi_power_resource *resource = NULL;
281
282         result = acpi_power_get_context(handle, &resource);
283         if (result)
284                 return result;
285
286         mutex_lock(&resource->resource_lock);
287
288         if (!resource->ref_count) {
289                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
290                                   "Power resource [%s] already off",
291                                   resource->name));
292                 goto unlock;
293         }
294
295         if (--resource->ref_count) {
296                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
297                                   "Power resource [%s] still in use\n",
298                                   resource->name));
299                 goto unlock;
300         }
301
302         status = acpi_evaluate_object(resource->device->handle, "_OFF", NULL, NULL);
303         if (ACPI_FAILURE(status)) {
304                 result = -ENODEV;
305         } else {
306                 /* Update the power resource's _device_ power state */
307                 resource->device->power.state = ACPI_STATE_D3;
308
309                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
310                                   "Power resource [%s] turned off\n",
311                                   resource->name));
312         }
313
314  unlock:
315         mutex_unlock(&resource->resource_lock);
316
317         return result;
318 }
319
320 static void __acpi_power_off_list(struct acpi_handle_list *list, int num_res)
321 {
322         int i;
323
324         for (i = num_res - 1; i >= 0 ; i--)
325                 acpi_power_off(list->handles[i]);
326 }
327
328 static void acpi_power_off_list(struct acpi_handle_list *list)
329 {
330         __acpi_power_off_list(list, list->count);
331 }
332
333 static int acpi_power_on_list(struct acpi_handle_list *list)
334 {
335         int result = 0;
336         int i;
337
338         for (i = 0; i < list->count; i++) {
339                 result = acpi_power_on(list->handles[i]);
340                 if (result) {
341                         __acpi_power_off_list(list, i);
342                         break;
343                 }
344         }
345
346         return result;
347 }
348
349 static void __acpi_power_resource_unregister_device(struct device *dev,
350                 acpi_handle res_handle)
351 {
352         struct acpi_power_resource *resource = NULL;
353         struct acpi_power_resource_device *prev, *curr;
354
355         if (acpi_power_get_context(res_handle, &resource))
356                 return;
357
358         mutex_lock(&resource->resource_lock);
359         prev = NULL;
360         curr = resource->devices;
361         while (curr) {
362                 if (curr->device->dev == dev) {
363                         if (!prev)
364                                 resource->devices = curr->next;
365                         else
366                                 prev->next = curr->next;
367
368                         kfree(curr);
369                         break;
370                 }
371
372                 prev = curr;
373                 curr = curr->next;
374         }
375         mutex_unlock(&resource->resource_lock);
376 }
377
378 /* Unlink dev from all power resources in _PR0 */
379 void acpi_power_resource_unregister_device(struct device *dev, acpi_handle handle)
380 {
381         struct acpi_device *acpi_dev;
382         struct acpi_handle_list *list;
383         int i;
384
385         if (!dev || !handle)
386                 return;
387
388         if (acpi_bus_get_device(handle, &acpi_dev))
389                 return;
390
391         list = &acpi_dev->power.states[ACPI_STATE_D0].resources;
392
393         for (i = 0; i < list->count; i++)
394                 __acpi_power_resource_unregister_device(dev,
395                         list->handles[i]);
396 }
397 EXPORT_SYMBOL_GPL(acpi_power_resource_unregister_device);
398
399 static int __acpi_power_resource_register_device(
400         struct acpi_power_managed_device *powered_device, acpi_handle handle)
401 {
402         struct acpi_power_resource *resource = NULL;
403         struct acpi_power_resource_device *power_resource_device;
404         int result;
405
406         result = acpi_power_get_context(handle, &resource);
407         if (result)
408                 return result;
409
410         power_resource_device = kzalloc(
411                 sizeof(*power_resource_device), GFP_KERNEL);
412         if (!power_resource_device)
413                 return -ENOMEM;
414
415         power_resource_device->device = powered_device;
416
417         mutex_lock(&resource->resource_lock);
418         power_resource_device->next = resource->devices;
419         resource->devices = power_resource_device;
420         mutex_unlock(&resource->resource_lock);
421
422         return 0;
423 }
424
425 /* Link dev to all power resources in _PR0 */
426 int acpi_power_resource_register_device(struct device *dev, acpi_handle handle)
427 {
428         struct acpi_device *acpi_dev;
429         struct acpi_handle_list *list;
430         struct acpi_power_managed_device *powered_device;
431         int i, ret;
432
433         if (!dev || !handle)
434                 return -ENODEV;
435
436         ret = acpi_bus_get_device(handle, &acpi_dev);
437         if (ret)
438                 goto no_power_resource;
439
440         if (!acpi_dev->power.flags.power_resources)
441                 goto no_power_resource;
442
443         powered_device = kzalloc(sizeof(*powered_device), GFP_KERNEL);
444         if (!powered_device)
445                 return -ENOMEM;
446
447         powered_device->dev = dev;
448         powered_device->handle = handle;
449
450         list = &acpi_dev->power.states[ACPI_STATE_D0].resources;
451
452         for (i = 0; i < list->count; i++) {
453                 ret = __acpi_power_resource_register_device(powered_device,
454                         list->handles[i]);
455
456                 if (ret) {
457                         acpi_power_resource_unregister_device(dev, handle);
458                         break;
459                 }
460         }
461
462         return ret;
463
464 no_power_resource:
465         printk(KERN_WARNING PREFIX "Invalid Power Resource to register!");
466         return -ENODEV;
467 }
468 EXPORT_SYMBOL_GPL(acpi_power_resource_register_device);
469
470 /**
471  * acpi_device_sleep_wake - execute _DSW (Device Sleep Wake) or (deprecated in
472  *                          ACPI 3.0) _PSW (Power State Wake)
473  * @dev: Device to handle.
474  * @enable: 0 - disable, 1 - enable the wake capabilities of the device.
475  * @sleep_state: Target sleep state of the system.
476  * @dev_state: Target power state of the device.
477  *
478  * Execute _DSW (Device Sleep Wake) or (deprecated in ACPI 3.0) _PSW (Power
479  * State Wake) for the device, if present.  On failure reset the device's
480  * wakeup.flags.valid flag.
481  *
482  * RETURN VALUE:
483  * 0 if either _DSW or _PSW has been successfully executed
484  * 0 if neither _DSW nor _PSW has been found
485  * -ENODEV if the execution of either _DSW or _PSW has failed
486  */
487 int acpi_device_sleep_wake(struct acpi_device *dev,
488                            int enable, int sleep_state, int dev_state)
489 {
490         union acpi_object in_arg[3];
491         struct acpi_object_list arg_list = { 3, in_arg };
492         acpi_status status = AE_OK;
493
494         /*
495          * Try to execute _DSW first.
496          *
497          * Three agruments are needed for the _DSW object:
498          * Argument 0: enable/disable the wake capabilities
499          * Argument 1: target system state
500          * Argument 2: target device state
501          * When _DSW object is called to disable the wake capabilities, maybe
502          * the first argument is filled. The values of the other two agruments
503          * are meaningless.
504          */
505         in_arg[0].type = ACPI_TYPE_INTEGER;
506         in_arg[0].integer.value = enable;
507         in_arg[1].type = ACPI_TYPE_INTEGER;
508         in_arg[1].integer.value = sleep_state;
509         in_arg[2].type = ACPI_TYPE_INTEGER;
510         in_arg[2].integer.value = dev_state;
511         status = acpi_evaluate_object(dev->handle, "_DSW", &arg_list, NULL);
512         if (ACPI_SUCCESS(status)) {
513                 return 0;
514         } else if (status != AE_NOT_FOUND) {
515                 printk(KERN_ERR PREFIX "_DSW execution failed\n");
516                 dev->wakeup.flags.valid = 0;
517                 return -ENODEV;
518         }
519
520         /* Execute _PSW */
521         arg_list.count = 1;
522         in_arg[0].integer.value = enable;
523         status = acpi_evaluate_object(dev->handle, "_PSW", &arg_list, NULL);
524         if (ACPI_FAILURE(status) && (status != AE_NOT_FOUND)) {
525                 printk(KERN_ERR PREFIX "_PSW execution failed\n");
526                 dev->wakeup.flags.valid = 0;
527                 return -ENODEV;
528         }
529
530         return 0;
531 }
532
533 /*
534  * Prepare a wakeup device, two steps (Ref ACPI 2.0:P229):
535  * 1. Power on the power resources required for the wakeup device 
536  * 2. Execute _DSW (Device Sleep Wake) or (deprecated in ACPI 3.0) _PSW (Power
537  *    State Wake) for the device, if present
538  */
539 int acpi_enable_wakeup_device_power(struct acpi_device *dev, int sleep_state)
540 {
541         int i, err = 0;
542
543         if (!dev || !dev->wakeup.flags.valid)
544                 return -EINVAL;
545
546         mutex_lock(&acpi_device_lock);
547
548         if (dev->wakeup.prepare_count++)
549                 goto out;
550
551         /* Open power resource */
552         for (i = 0; i < dev->wakeup.resources.count; i++) {
553                 int ret = acpi_power_on(dev->wakeup.resources.handles[i]);
554                 if (ret) {
555                         printk(KERN_ERR PREFIX "Transition power state\n");
556                         dev->wakeup.flags.valid = 0;
557                         err = -ENODEV;
558                         goto err_out;
559                 }
560         }
561
562         /*
563          * Passing 3 as the third argument below means the device may be placed
564          * in arbitrary power state afterwards.
565          */
566         err = acpi_device_sleep_wake(dev, 1, sleep_state, 3);
567
568  err_out:
569         if (err)
570                 dev->wakeup.prepare_count = 0;
571
572  out:
573         mutex_unlock(&acpi_device_lock);
574         return err;
575 }
576
577 /*
578  * Shutdown a wakeup device, counterpart of above method
579  * 1. Execute _DSW (Device Sleep Wake) or (deprecated in ACPI 3.0) _PSW (Power
580  *    State Wake) for the device, if present
581  * 2. Shutdown down the power resources
582  */
583 int acpi_disable_wakeup_device_power(struct acpi_device *dev)
584 {
585         int i, err = 0;
586
587         if (!dev || !dev->wakeup.flags.valid)
588                 return -EINVAL;
589
590         mutex_lock(&acpi_device_lock);
591
592         if (--dev->wakeup.prepare_count > 0)
593                 goto out;
594
595         /*
596          * Executing the code below even if prepare_count is already zero when
597          * the function is called may be useful, for example for initialisation.
598          */
599         if (dev->wakeup.prepare_count < 0)
600                 dev->wakeup.prepare_count = 0;
601
602         err = acpi_device_sleep_wake(dev, 0, 0, 0);
603         if (err)
604                 goto out;
605
606         /* Close power resource */
607         for (i = 0; i < dev->wakeup.resources.count; i++) {
608                 int ret = acpi_power_off(dev->wakeup.resources.handles[i]);
609                 if (ret) {
610                         printk(KERN_ERR PREFIX "Transition power state\n");
611                         dev->wakeup.flags.valid = 0;
612                         err = -ENODEV;
613                         goto out;
614                 }
615         }
616
617  out:
618         mutex_unlock(&acpi_device_lock);
619         return err;
620 }
621
622 /* --------------------------------------------------------------------------
623                              Device Power Management
624    -------------------------------------------------------------------------- */
625
626 int acpi_power_get_inferred_state(struct acpi_device *device, int *state)
627 {
628         int result = 0;
629         struct acpi_handle_list *list = NULL;
630         int list_state = 0;
631         int i = 0;
632
633         if (!device || !state)
634                 return -EINVAL;
635
636         /*
637          * We know a device's inferred power state when all the resources
638          * required for a given D-state are 'on'.
639          */
640         for (i = ACPI_STATE_D0; i <= ACPI_STATE_D3_HOT; i++) {
641                 list = &device->power.states[i].resources;
642                 if (list->count < 1)
643                         continue;
644
645                 result = acpi_power_get_list_state(list, &list_state);
646                 if (result)
647                         return result;
648
649                 if (list_state == ACPI_POWER_RESOURCE_STATE_ON) {
650                         *state = i;
651                         return 0;
652                 }
653         }
654
655         *state = ACPI_STATE_D3;
656         return 0;
657 }
658
659 int acpi_power_on_resources(struct acpi_device *device, int state)
660 {
661         if (!device || state < ACPI_STATE_D0 || state > ACPI_STATE_D3)
662                 return -EINVAL;
663
664         return acpi_power_on_list(&device->power.states[state].resources);
665 }
666
667 int acpi_power_transition(struct acpi_device *device, int state)
668 {
669         int result = 0;
670
671         if (!device || (state < ACPI_STATE_D0) || (state > ACPI_STATE_D3_COLD))
672                 return -EINVAL;
673
674         if (device->power.state == state)
675                 return 0;
676
677         if ((device->power.state < ACPI_STATE_D0)
678             || (device->power.state > ACPI_STATE_D3_COLD))
679                 return -ENODEV;
680
681         /* TBD: Resources must be ordered. */
682
683         /*
684          * First we reference all power resources required in the target list
685          * (e.g. so the device doesn't lose power while transitioning).  Then,
686          * we dereference all power resources used in the current list.
687          */
688         if (state < ACPI_STATE_D3_COLD)
689                 result = acpi_power_on_list(
690                         &device->power.states[state].resources);
691
692         if (!result && device->power.state < ACPI_STATE_D3_COLD)
693                 acpi_power_off_list(
694                         &device->power.states[device->power.state].resources);
695
696         /* We shouldn't change the state unless the above operations succeed. */
697         device->power.state = result ? ACPI_STATE_UNKNOWN : state;
698
699         return result;
700 }
701
702 /* --------------------------------------------------------------------------
703                                 Driver Interface
704    -------------------------------------------------------------------------- */
705
706 static int acpi_power_add(struct acpi_device *device)
707 {
708         int result = 0, state;
709         acpi_status status = AE_OK;
710         struct acpi_power_resource *resource = NULL;
711         union acpi_object acpi_object;
712         struct acpi_buffer buffer = { sizeof(acpi_object), &acpi_object };
713
714
715         if (!device)
716                 return -EINVAL;
717
718         resource = kzalloc(sizeof(struct acpi_power_resource), GFP_KERNEL);
719         if (!resource)
720                 return -ENOMEM;
721
722         resource->device = device;
723         mutex_init(&resource->resource_lock);
724         strcpy(resource->name, device->pnp.bus_id);
725         strcpy(acpi_device_name(device), ACPI_POWER_DEVICE_NAME);
726         strcpy(acpi_device_class(device), ACPI_POWER_CLASS);
727         device->driver_data = resource;
728
729         /* Evalute the object to get the system level and resource order. */
730         status = acpi_evaluate_object(device->handle, NULL, NULL, &buffer);
731         if (ACPI_FAILURE(status)) {
732                 result = -ENODEV;
733                 goto end;
734         }
735         resource->system_level = acpi_object.power_resource.system_level;
736         resource->order = acpi_object.power_resource.resource_order;
737
738         result = acpi_power_get_state(device->handle, &state);
739         if (result)
740                 goto end;
741
742         switch (state) {
743         case ACPI_POWER_RESOURCE_STATE_ON:
744                 device->power.state = ACPI_STATE_D0;
745                 break;
746         case ACPI_POWER_RESOURCE_STATE_OFF:
747                 device->power.state = ACPI_STATE_D3;
748                 break;
749         default:
750                 device->power.state = ACPI_STATE_UNKNOWN;
751                 break;
752         }
753
754         printk(KERN_INFO PREFIX "%s [%s] (%s)\n", acpi_device_name(device),
755                acpi_device_bid(device), state ? "on" : "off");
756
757       end:
758         if (result)
759                 kfree(resource);
760
761         return result;
762 }
763
764 static int acpi_power_remove(struct acpi_device *device, int type)
765 {
766         struct acpi_power_resource *resource;
767
768         if (!device)
769                 return -EINVAL;
770
771         resource = acpi_driver_data(device);
772         if (!resource)
773                 return -EINVAL;
774
775         kfree(resource);
776
777         return 0;
778 }
779
780 #ifdef CONFIG_PM_SLEEP
781 static int acpi_power_resume(struct device *dev)
782 {
783         int result = 0, state;
784         struct acpi_device *device;
785         struct acpi_power_resource *resource;
786
787         if (!dev)
788                 return -EINVAL;
789
790         device = to_acpi_device(dev);
791         resource = acpi_driver_data(device);
792         if (!resource)
793                 return -EINVAL;
794
795         mutex_lock(&resource->resource_lock);
796
797         result = acpi_power_get_state(device->handle, &state);
798         if (result)
799                 goto unlock;
800
801         if (state == ACPI_POWER_RESOURCE_STATE_OFF && resource->ref_count)
802                 result = __acpi_power_on(resource);
803
804  unlock:
805         mutex_unlock(&resource->resource_lock);
806
807         return result;
808 }
809 #endif
810
811 int __init acpi_power_init(void)
812 {
813         INIT_LIST_HEAD(&acpi_power_resource_list);
814         return acpi_bus_register_driver(&acpi_power_driver);
815 }