2 * acpi_power.c - ACPI Bus Power Management ($Revision: 39 $)
4 * Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
5 * Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
7 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
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.
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.
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.
23 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
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.
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.
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>
49 #define PREFIX "ACPI: "
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
61 static int acpi_power_add(struct acpi_device *device);
62 static int acpi_power_remove(struct acpi_device *device, int type);
64 static const struct acpi_device_id power_device_ids[] = {
68 MODULE_DEVICE_TABLE(acpi, power_device_ids);
70 static int acpi_power_resume(struct device *dev);
71 static SIMPLE_DEV_PM_OPS(acpi_power_pm, NULL, acpi_power_resume);
73 static struct acpi_driver acpi_power_driver = {
75 .class = ACPI_POWER_CLASS,
76 .ids = power_device_ids,
78 .add = acpi_power_add,
79 .remove = acpi_power_remove,
81 .drv.pm = &acpi_power_pm,
85 * A power managed device
86 * A device may rely on multiple power resources.
88 struct acpi_power_managed_device {
89 struct device *dev; /* The physical device */
93 struct acpi_power_resource_device {
94 struct acpi_power_managed_device *device;
95 struct acpi_power_resource_device *next;
98 struct acpi_power_resource {
99 struct acpi_device * device;
103 unsigned int ref_count;
104 struct mutex resource_lock;
106 /* List of devices relying on this power resource */
107 struct acpi_power_resource_device *devices;
110 static struct list_head acpi_power_resource_list;
112 /* --------------------------------------------------------------------------
113 Power Resource Management
114 -------------------------------------------------------------------------- */
117 acpi_power_get_context(acpi_handle handle,
118 struct acpi_power_resource **resource)
121 struct acpi_device *device = NULL;
127 result = acpi_bus_get_device(handle, &device);
129 printk(KERN_WARNING PREFIX "Getting context [%p]\n", handle);
133 *resource = acpi_driver_data(device);
140 static int acpi_power_get_state(acpi_handle handle, int *state)
142 acpi_status status = AE_OK;
143 unsigned long long sta = 0;
145 struct acpi_buffer buffer = { sizeof(node_name), node_name };
148 if (!handle || !state)
151 status = acpi_evaluate_integer(handle, "_STA", NULL, &sta);
152 if (ACPI_FAILURE(status))
155 *state = (sta & 0x01)?ACPI_POWER_RESOURCE_STATE_ON:
156 ACPI_POWER_RESOURCE_STATE_OFF;
158 acpi_get_name(handle, ACPI_SINGLE_NAME, &buffer);
160 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Resource [%s] is %s\n",
162 *state ? "on" : "off"));
167 static int acpi_power_get_list_state(struct acpi_handle_list *list, int *state)
175 /* The state of the list is 'on' IFF all resources are 'on'. */
177 for (i = 0; i < list->count; i++) {
178 struct acpi_power_resource *resource;
179 acpi_handle handle = list->handles[i];
182 result = acpi_power_get_context(handle, &resource);
186 mutex_lock(&resource->resource_lock);
188 result = acpi_power_get_state(handle, &cur_state);
190 mutex_unlock(&resource->resource_lock);
195 if (cur_state != ACPI_POWER_RESOURCE_STATE_ON)
199 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Resource list is %s\n",
200 cur_state ? "on" : "off"));
207 /* Resume the device when all power resources in _PR0 are on */
208 static void acpi_power_on_device(struct acpi_power_managed_device *device)
210 struct acpi_device *acpi_dev;
211 acpi_handle handle = device->handle;
214 if (acpi_bus_get_device(handle, &acpi_dev))
217 if(acpi_power_get_inferred_state(acpi_dev, &state))
220 if (state == ACPI_STATE_D0 && pm_runtime_suspended(device->dev))
221 pm_request_resume(device->dev);
224 static int __acpi_power_on(struct acpi_power_resource *resource)
226 struct acpi_power_resource_device *device_list = resource->devices;
227 acpi_status status = AE_OK;
229 status = acpi_evaluate_object(resource->device->handle, "_ON", NULL, NULL);
230 if (ACPI_FAILURE(status))
233 /* Update the power resource's _device_ power state */
234 resource->device->power.state = ACPI_STATE_D0;
236 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Power resource [%s] turned on\n",
239 while (device_list) {
240 acpi_power_on_device(device_list->device);
242 device_list = device_list->next;
248 static int acpi_power_on(acpi_handle handle)
251 struct acpi_power_resource *resource = NULL;
253 result = acpi_power_get_context(handle, &resource);
257 mutex_lock(&resource->resource_lock);
259 if (resource->ref_count++) {
260 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
261 "Power resource [%s] already on",
264 result = __acpi_power_on(resource);
266 resource->ref_count--;
269 mutex_unlock(&resource->resource_lock);
274 static int acpi_power_off(acpi_handle handle)
277 acpi_status status = AE_OK;
278 struct acpi_power_resource *resource = NULL;
280 result = acpi_power_get_context(handle, &resource);
284 mutex_lock(&resource->resource_lock);
286 if (!resource->ref_count) {
287 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
288 "Power resource [%s] already off",
293 if (--resource->ref_count) {
294 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
295 "Power resource [%s] still in use\n",
300 status = acpi_evaluate_object(resource->device->handle, "_OFF", NULL, NULL);
301 if (ACPI_FAILURE(status)) {
304 /* Update the power resource's _device_ power state */
305 resource->device->power.state = ACPI_STATE_D3;
307 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
308 "Power resource [%s] turned off\n",
313 mutex_unlock(&resource->resource_lock);
318 static void __acpi_power_off_list(struct acpi_handle_list *list, int num_res)
322 for (i = num_res - 1; i >= 0 ; i--)
323 acpi_power_off(list->handles[i]);
326 static void acpi_power_off_list(struct acpi_handle_list *list)
328 __acpi_power_off_list(list, list->count);
331 static int acpi_power_on_list(struct acpi_handle_list *list)
336 for (i = 0; i < list->count; i++) {
337 result = acpi_power_on(list->handles[i]);
339 __acpi_power_off_list(list, i);
347 static void __acpi_power_resource_unregister_device(struct device *dev,
348 acpi_handle res_handle)
350 struct acpi_power_resource *resource = NULL;
351 struct acpi_power_resource_device *prev, *curr;
353 if (acpi_power_get_context(res_handle, &resource))
356 mutex_lock(&resource->resource_lock);
358 curr = resource->devices;
360 if (curr->device->dev == dev) {
362 resource->devices = curr->next;
364 prev->next = curr->next;
373 mutex_unlock(&resource->resource_lock);
376 /* Unlink dev from all power resources in _PR0 */
377 void acpi_power_resource_unregister_device(struct device *dev, acpi_handle handle)
379 struct acpi_device *acpi_dev;
380 struct acpi_handle_list *list;
386 if (acpi_bus_get_device(handle, &acpi_dev))
389 list = &acpi_dev->power.states[ACPI_STATE_D0].resources;
391 for (i = 0; i < list->count; i++)
392 __acpi_power_resource_unregister_device(dev,
396 static int __acpi_power_resource_register_device(
397 struct acpi_power_managed_device *powered_device, acpi_handle handle)
399 struct acpi_power_resource *resource = NULL;
400 struct acpi_power_resource_device *power_resource_device;
403 result = acpi_power_get_context(handle, &resource);
407 power_resource_device = kzalloc(
408 sizeof(*power_resource_device), GFP_KERNEL);
409 if (!power_resource_device)
412 power_resource_device->device = powered_device;
414 mutex_lock(&resource->resource_lock);
415 power_resource_device->next = resource->devices;
416 resource->devices = power_resource_device;
417 mutex_unlock(&resource->resource_lock);
422 /* Link dev to all power resources in _PR0 */
423 int acpi_power_resource_register_device(struct device *dev, acpi_handle handle)
425 struct acpi_device *acpi_dev;
426 struct acpi_handle_list *list;
427 struct acpi_power_managed_device *powered_device;
433 ret = acpi_bus_get_device(handle, &acpi_dev);
435 goto no_power_resource;
437 if (!acpi_dev->power.flags.power_resources)
438 goto no_power_resource;
440 powered_device = kzalloc(sizeof(*powered_device), GFP_KERNEL);
444 powered_device->dev = dev;
445 powered_device->handle = handle;
447 list = &acpi_dev->power.states[ACPI_STATE_D0].resources;
449 for (i = 0; i < list->count; i++) {
450 ret = __acpi_power_resource_register_device(powered_device,
454 acpi_power_resource_unregister_device(dev, handle);
462 printk(KERN_WARNING PREFIX "Invalid Power Resource to register!");
467 * acpi_device_sleep_wake - execute _DSW (Device Sleep Wake) or (deprecated in
468 * ACPI 3.0) _PSW (Power State Wake)
469 * @dev: Device to handle.
470 * @enable: 0 - disable, 1 - enable the wake capabilities of the device.
471 * @sleep_state: Target sleep state of the system.
472 * @dev_state: Target power state of the device.
474 * Execute _DSW (Device Sleep Wake) or (deprecated in ACPI 3.0) _PSW (Power
475 * State Wake) for the device, if present. On failure reset the device's
476 * wakeup.flags.valid flag.
479 * 0 if either _DSW or _PSW has been successfully executed
480 * 0 if neither _DSW nor _PSW has been found
481 * -ENODEV if the execution of either _DSW or _PSW has failed
483 int acpi_device_sleep_wake(struct acpi_device *dev,
484 int enable, int sleep_state, int dev_state)
486 union acpi_object in_arg[3];
487 struct acpi_object_list arg_list = { 3, in_arg };
488 acpi_status status = AE_OK;
491 * Try to execute _DSW first.
493 * Three agruments are needed for the _DSW object:
494 * Argument 0: enable/disable the wake capabilities
495 * Argument 1: target system state
496 * Argument 2: target device state
497 * When _DSW object is called to disable the wake capabilities, maybe
498 * the first argument is filled. The values of the other two agruments
501 in_arg[0].type = ACPI_TYPE_INTEGER;
502 in_arg[0].integer.value = enable;
503 in_arg[1].type = ACPI_TYPE_INTEGER;
504 in_arg[1].integer.value = sleep_state;
505 in_arg[2].type = ACPI_TYPE_INTEGER;
506 in_arg[2].integer.value = dev_state;
507 status = acpi_evaluate_object(dev->handle, "_DSW", &arg_list, NULL);
508 if (ACPI_SUCCESS(status)) {
510 } else if (status != AE_NOT_FOUND) {
511 printk(KERN_ERR PREFIX "_DSW execution failed\n");
512 dev->wakeup.flags.valid = 0;
518 in_arg[0].integer.value = enable;
519 status = acpi_evaluate_object(dev->handle, "_PSW", &arg_list, NULL);
520 if (ACPI_FAILURE(status) && (status != AE_NOT_FOUND)) {
521 printk(KERN_ERR PREFIX "_PSW execution failed\n");
522 dev->wakeup.flags.valid = 0;
530 * Prepare a wakeup device, two steps (Ref ACPI 2.0:P229):
531 * 1. Power on the power resources required for the wakeup device
532 * 2. Execute _DSW (Device Sleep Wake) or (deprecated in ACPI 3.0) _PSW (Power
533 * State Wake) for the device, if present
535 int acpi_enable_wakeup_device_power(struct acpi_device *dev, int sleep_state)
539 if (!dev || !dev->wakeup.flags.valid)
542 mutex_lock(&acpi_device_lock);
544 if (dev->wakeup.prepare_count++)
547 /* Open power resource */
548 for (i = 0; i < dev->wakeup.resources.count; i++) {
549 int ret = acpi_power_on(dev->wakeup.resources.handles[i]);
551 printk(KERN_ERR PREFIX "Transition power state\n");
552 dev->wakeup.flags.valid = 0;
559 * Passing 3 as the third argument below means the device may be placed
560 * in arbitrary power state afterwards.
562 err = acpi_device_sleep_wake(dev, 1, sleep_state, 3);
566 dev->wakeup.prepare_count = 0;
569 mutex_unlock(&acpi_device_lock);
574 * Shutdown a wakeup device, counterpart of above method
575 * 1. Execute _DSW (Device Sleep Wake) or (deprecated in ACPI 3.0) _PSW (Power
576 * State Wake) for the device, if present
577 * 2. Shutdown down the power resources
579 int acpi_disable_wakeup_device_power(struct acpi_device *dev)
583 if (!dev || !dev->wakeup.flags.valid)
586 mutex_lock(&acpi_device_lock);
588 if (--dev->wakeup.prepare_count > 0)
592 * Executing the code below even if prepare_count is already zero when
593 * the function is called may be useful, for example for initialisation.
595 if (dev->wakeup.prepare_count < 0)
596 dev->wakeup.prepare_count = 0;
598 err = acpi_device_sleep_wake(dev, 0, 0, 0);
602 /* Close power resource */
603 for (i = 0; i < dev->wakeup.resources.count; i++) {
604 int ret = acpi_power_off(dev->wakeup.resources.handles[i]);
606 printk(KERN_ERR PREFIX "Transition power state\n");
607 dev->wakeup.flags.valid = 0;
614 mutex_unlock(&acpi_device_lock);
618 /* --------------------------------------------------------------------------
619 Device Power Management
620 -------------------------------------------------------------------------- */
622 int acpi_power_get_inferred_state(struct acpi_device *device, int *state)
625 struct acpi_handle_list *list = NULL;
629 if (!device || !state)
633 * We know a device's inferred power state when all the resources
634 * required for a given D-state are 'on'.
636 for (i = ACPI_STATE_D0; i <= ACPI_STATE_D3_HOT; i++) {
637 list = &device->power.states[i].resources;
641 result = acpi_power_get_list_state(list, &list_state);
645 if (list_state == ACPI_POWER_RESOURCE_STATE_ON) {
651 *state = ACPI_STATE_D3;
655 int acpi_power_on_resources(struct acpi_device *device, int state)
657 if (!device || state < ACPI_STATE_D0 || state > ACPI_STATE_D3)
660 return acpi_power_on_list(&device->power.states[state].resources);
663 int acpi_power_transition(struct acpi_device *device, int state)
667 if (!device || (state < ACPI_STATE_D0) || (state > ACPI_STATE_D3_COLD))
670 if (device->power.state == state)
673 if ((device->power.state < ACPI_STATE_D0)
674 || (device->power.state > ACPI_STATE_D3_COLD))
677 /* TBD: Resources must be ordered. */
680 * First we reference all power resources required in the target list
681 * (e.g. so the device doesn't lose power while transitioning). Then,
682 * we dereference all power resources used in the current list.
684 if (state < ACPI_STATE_D3_COLD)
685 result = acpi_power_on_list(
686 &device->power.states[state].resources);
688 if (!result && device->power.state < ACPI_STATE_D3_COLD)
690 &device->power.states[device->power.state].resources);
692 /* We shouldn't change the state unless the above operations succeed. */
693 device->power.state = result ? ACPI_STATE_UNKNOWN : state;
698 /* --------------------------------------------------------------------------
700 -------------------------------------------------------------------------- */
702 static int acpi_power_add(struct acpi_device *device)
704 int result = 0, state;
705 acpi_status status = AE_OK;
706 struct acpi_power_resource *resource = NULL;
707 union acpi_object acpi_object;
708 struct acpi_buffer buffer = { sizeof(acpi_object), &acpi_object };
714 resource = kzalloc(sizeof(struct acpi_power_resource), GFP_KERNEL);
718 resource->device = device;
719 mutex_init(&resource->resource_lock);
720 strcpy(resource->name, device->pnp.bus_id);
721 strcpy(acpi_device_name(device), ACPI_POWER_DEVICE_NAME);
722 strcpy(acpi_device_class(device), ACPI_POWER_CLASS);
723 device->driver_data = resource;
725 /* Evalute the object to get the system level and resource order. */
726 status = acpi_evaluate_object(device->handle, NULL, NULL, &buffer);
727 if (ACPI_FAILURE(status)) {
731 resource->system_level = acpi_object.power_resource.system_level;
732 resource->order = acpi_object.power_resource.resource_order;
734 result = acpi_power_get_state(device->handle, &state);
739 case ACPI_POWER_RESOURCE_STATE_ON:
740 device->power.state = ACPI_STATE_D0;
742 case ACPI_POWER_RESOURCE_STATE_OFF:
743 device->power.state = ACPI_STATE_D3;
746 device->power.state = ACPI_STATE_UNKNOWN;
750 printk(KERN_INFO PREFIX "%s [%s] (%s)\n", acpi_device_name(device),
751 acpi_device_bid(device), state ? "on" : "off");
760 static int acpi_power_remove(struct acpi_device *device, int type)
762 struct acpi_power_resource *resource;
767 resource = acpi_driver_data(device);
776 static int acpi_power_resume(struct device *dev)
778 int result = 0, state;
779 struct acpi_device *device;
780 struct acpi_power_resource *resource;
785 device = to_acpi_device(dev);
786 resource = acpi_driver_data(device);
790 mutex_lock(&resource->resource_lock);
792 result = acpi_power_get_state(device->handle, &state);
796 if (state == ACPI_POWER_RESOURCE_STATE_OFF && resource->ref_count)
797 result = __acpi_power_on(resource);
800 mutex_unlock(&resource->resource_lock);
805 int __init acpi_power_init(void)
807 INIT_LIST_HEAD(&acpi_power_resource_list);
808 return acpi_bus_register_driver(&acpi_power_driver);