include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit...
[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/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 }