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