Version:  2.0.40 2.2.26 2.4.37 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16

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

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us