blob: 4fe5018fd6ab70b26bd06d4bc58d57d837e14a3c [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090042#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070043#include <acpi/acpi_bus.h>
44#include <acpi/acpi_drivers.h>
Rafael J. Wysocki9b83ccd2009-09-08 23:15:31 +020045#include "sleep.h"
46
Len Browna192a952009-07-28 16:45:54 -040047#define PREFIX "ACPI: "
48
Bjorn Helgaas89595b82008-11-07 16:57:45 -070049#define _COMPONENT ACPI_POWER_COMPONENT
Len Brownf52fd662007-02-12 22:42:12 -050050ACPI_MODULE_NAME("power");
Linus Torvalds1da177e2005-04-16 15:20:36 -070051#define ACPI_POWER_CLASS "power_resource"
Linus Torvalds1da177e2005-04-16 15:20:36 -070052#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
Zhao Yakuif5adfaa2008-08-11 14:57:50 +080058
Zhao Yakuif5adfaa2008-08-11 14:57:50 +080059int acpi_power_nocheck;
60module_param_named(power_nocheck, acpi_power_nocheck, bool, 000);
61
Len Brown4be44fc2005-08-05 00:44:28 -040062static int acpi_power_add(struct acpi_device *device);
63static int acpi_power_remove(struct acpi_device *device, int type);
Len Browne8363f32007-02-16 02:05:39 -050064static int acpi_power_resume(struct acpi_device *device);
Linus Torvalds1da177e2005-04-16 15:20:36 -070065
Márton Némethc97adf92010-01-10 17:15:36 +010066static const struct acpi_device_id power_device_ids[] = {
Thomas Renninger1ba90e32007-07-23 14:44:41 +020067 {ACPI_POWER_HID, 0},
68 {"", 0},
69};
70MODULE_DEVICE_TABLE(acpi, power_device_ids);
71
Linus Torvalds1da177e2005-04-16 15:20:36 -070072static struct acpi_driver acpi_power_driver = {
Len Brownc2b67052007-02-12 23:33:40 -050073 .name = "power",
Len Brown4be44fc2005-08-05 00:44:28 -040074 .class = ACPI_POWER_CLASS,
Thomas Renninger1ba90e32007-07-23 14:44:41 +020075 .ids = power_device_ids,
Len Brown4be44fc2005-08-05 00:44:28 -040076 .ops = {
77 .add = acpi_power_add,
78 .remove = acpi_power_remove,
Konstantin Karasyov0a613902007-02-16 01:47:06 -050079 .resume = acpi_power_resume,
Len Brown4be44fc2005-08-05 00:44:28 -040080 },
Linus Torvalds1da177e2005-04-16 15:20:36 -070081};
82
Konstantin Karasyov0a613902007-02-16 01:47:06 -050083struct acpi_power_reference {
84 struct list_head node;
85 struct acpi_device *device;
86};
87
Len Brown4be44fc2005-08-05 00:44:28 -040088struct acpi_power_resource {
Patrick Mochel41598572006-05-19 16:54:40 -040089 struct acpi_device * device;
Len Brown4be44fc2005-08-05 00:44:28 -040090 acpi_bus_id name;
91 u32 system_level;
92 u32 order;
Konstantin Karasyov0a613902007-02-16 01:47:06 -050093 struct mutex resource_lock;
94 struct list_head reference;
Linus Torvalds1da177e2005-04-16 15:20:36 -070095};
96
Len Brown4be44fc2005-08-05 00:44:28 -040097static struct list_head acpi_power_resource_list;
Linus Torvalds1da177e2005-04-16 15:20:36 -070098
Linus Torvalds1da177e2005-04-16 15:20:36 -070099/* --------------------------------------------------------------------------
100 Power Resource Management
101 -------------------------------------------------------------------------- */
102
103static int
Len Brown4be44fc2005-08-05 00:44:28 -0400104acpi_power_get_context(acpi_handle handle,
105 struct acpi_power_resource **resource)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106{
Len Brown4be44fc2005-08-05 00:44:28 -0400107 int result = 0;
108 struct acpi_device *device = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110
111 if (!resource)
Patrick Mocheld550d982006-06-27 00:41:40 -0400112 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113
114 result = acpi_bus_get_device(handle, &device);
115 if (result) {
Len Browncece9292006-06-26 23:04:31 -0400116 printk(KERN_WARNING PREFIX "Getting context [%p]\n", handle);
Patrick Mocheld550d982006-06-27 00:41:40 -0400117 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700118 }
119
Jan Engelhardt50dd0962006-10-01 00:28:50 +0200120 *resource = acpi_driver_data(device);
Li Zefana815ab82008-04-18 13:27:29 -0700121 if (!*resource)
Patrick Mocheld550d982006-06-27 00:41:40 -0400122 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700123
Patrick Mocheld550d982006-06-27 00:41:40 -0400124 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700125}
126
Zhao Yakuia51e1452008-08-11 14:55:05 +0800127static int acpi_power_get_state(acpi_handle handle, int *state)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700128{
Len Brown4be44fc2005-08-05 00:44:28 -0400129 acpi_status status = AE_OK;
Matthew Wilcox27663c52008-10-10 02:22:59 -0400130 unsigned long long sta = 0;
Lin Ming60a4ce72008-12-16 17:02:22 +0800131 char node_name[5];
132 struct acpi_buffer buffer = { sizeof(node_name), node_name };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133
Linus Torvalds1da177e2005-04-16 15:20:36 -0700134
Zhao Yakuia51e1452008-08-11 14:55:05 +0800135 if (!handle || !state)
Patrick Mocheld550d982006-06-27 00:41:40 -0400136 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137
Zhao Yakuia51e1452008-08-11 14:55:05 +0800138 status = acpi_evaluate_integer(handle, "_STA", NULL, &sta);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139 if (ACPI_FAILURE(status))
Patrick Mocheld550d982006-06-27 00:41:40 -0400140 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141
Alexey Starikovskiyc35923b2007-10-22 14:19:09 +0400142 *state = (sta & 0x01)?ACPI_POWER_RESOURCE_STATE_ON:
143 ACPI_POWER_RESOURCE_STATE_OFF;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144
Lin Ming60a4ce72008-12-16 17:02:22 +0800145 acpi_get_name(handle, ACPI_SINGLE_NAME, &buffer);
146
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Resource [%s] is %s\n",
Lin Ming60a4ce72008-12-16 17:02:22 +0800148 node_name,
Zhao Yakuib1b57fb2008-10-27 16:04:53 +0800149 *state ? "on" : "off"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150
Patrick Mocheld550d982006-06-27 00:41:40 -0400151 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152}
153
Len Brown4be44fc2005-08-05 00:44:28 -0400154static int acpi_power_get_list_state(struct acpi_handle_list *list, int *state)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700155{
Alexey Starikovskiyc35923b2007-10-22 14:19:09 +0400156 int result = 0, state1;
Len Brown4be44fc2005-08-05 00:44:28 -0400157 u32 i = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700158
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159
160 if (!list || !state)
Patrick Mocheld550d982006-06-27 00:41:40 -0400161 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700162
163 /* The state of the list is 'on' IFF all resources are 'on'. */
164
Len Brown4be44fc2005-08-05 00:44:28 -0400165 for (i = 0; i < list->count; i++) {
Zhao Yakuia51e1452008-08-11 14:55:05 +0800166 /*
167 * The state of the power resource can be obtained by
168 * using the ACPI handle. In such case it is unnecessary to
169 * get the Power resource first and then get its state again.
170 */
171 result = acpi_power_get_state(list->handles[i], &state1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700172 if (result)
Patrick Mocheld550d982006-06-27 00:41:40 -0400173 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700174
Alexey Starikovskiyc35923b2007-10-22 14:19:09 +0400175 *state = state1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700176
177 if (*state != ACPI_POWER_RESOURCE_STATE_ON)
178 break;
179 }
180
181 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Resource list is %s\n",
Len Brown4be44fc2005-08-05 00:44:28 -0400182 *state ? "on" : "off"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700183
Patrick Mocheld550d982006-06-27 00:41:40 -0400184 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700185}
186
Konstantin Karasyov0a613902007-02-16 01:47:06 -0500187static int acpi_power_on(acpi_handle handle, struct acpi_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700188{
Bjorn Helgaasbdf43bb2009-05-21 17:28:53 -0600189 int result = 0;
Konstantin Karasyov0a613902007-02-16 01:47:06 -0500190 int found = 0;
Len Brown4be44fc2005-08-05 00:44:28 -0400191 acpi_status status = AE_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192 struct acpi_power_resource *resource = NULL;
Konstantin Karasyov0a613902007-02-16 01:47:06 -0500193 struct list_head *node, *next;
194 struct acpi_power_reference *ref;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195
Linus Torvalds1da177e2005-04-16 15:20:36 -0700196
197 result = acpi_power_get_context(handle, &resource);
198 if (result)
Patrick Mocheld550d982006-06-27 00:41:40 -0400199 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200
Konstantin Karasyov0a613902007-02-16 01:47:06 -0500201 mutex_lock(&resource->resource_lock);
202 list_for_each_safe(node, next, &resource->reference) {
203 ref = container_of(node, struct acpi_power_reference, node);
204 if (dev->handle == ref->device->handle) {
205 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device [%s] already referenced by resource [%s]\n",
206 dev->pnp.bus_id, resource->name));
207 found = 1;
208 break;
209 }
210 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211
Konstantin Karasyov0a613902007-02-16 01:47:06 -0500212 if (!found) {
213 ref = kmalloc(sizeof (struct acpi_power_reference),
214 irqs_disabled() ? GFP_ATOMIC : GFP_KERNEL);
215 if (!ref) {
216 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "kmalloc() failed\n"));
217 mutex_unlock(&resource->resource_lock);
218 return -ENOMEM;
219 }
220 list_add_tail(&ref->node, &resource->reference);
221 ref->device = dev;
222 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device [%s] added to resource [%s] references\n",
223 dev->pnp.bus_id, resource->name));
224 }
225 mutex_unlock(&resource->resource_lock);
226
Patrick Mochel5fbc19e2006-05-19 16:54:43 -0400227 status = acpi_evaluate_object(resource->device->handle, "_ON", NULL, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228 if (ACPI_FAILURE(status))
Patrick Mocheld550d982006-06-27 00:41:40 -0400229 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700230
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231 /* Update the power resource's _device_ power state */
Patrick Mochel41598572006-05-19 16:54:40 -0400232 resource->device->power.state = ACPI_STATE_D0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233
234 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Resource [%s] turned on\n",
Len Brown4be44fc2005-08-05 00:44:28 -0400235 resource->name));
Patrick Mocheld550d982006-06-27 00:41:40 -0400236 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237}
238
Konstantin Karasyov0a613902007-02-16 01:47:06 -0500239static int acpi_power_off_device(acpi_handle handle, struct acpi_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700240{
Bjorn Helgaasbdf43bb2009-05-21 17:28:53 -0600241 int result = 0;
Len Brown4be44fc2005-08-05 00:44:28 -0400242 acpi_status status = AE_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243 struct acpi_power_resource *resource = NULL;
Konstantin Karasyov0a613902007-02-16 01:47:06 -0500244 struct list_head *node, *next;
245 struct acpi_power_reference *ref;
246
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247
Linus Torvalds1da177e2005-04-16 15:20:36 -0700248 result = acpi_power_get_context(handle, &resource);
249 if (result)
Patrick Mocheld550d982006-06-27 00:41:40 -0400250 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251
Konstantin Karasyov0a613902007-02-16 01:47:06 -0500252 mutex_lock(&resource->resource_lock);
253 list_for_each_safe(node, next, &resource->reference) {
254 ref = container_of(node, struct acpi_power_reference, node);
255 if (dev->handle == ref->device->handle) {
256 list_del(&ref->node);
257 kfree(ref);
258 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device [%s] removed from resource [%s] references\n",
259 dev->pnp.bus_id, resource->name));
260 break;
261 }
262 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700263
Konstantin Karasyov0a613902007-02-16 01:47:06 -0500264 if (!list_empty(&resource->reference)) {
265 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Cannot turn resource [%s] off - resource is in use\n",
266 resource->name));
267 mutex_unlock(&resource->resource_lock);
Patrick Mocheld550d982006-06-27 00:41:40 -0400268 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269 }
Konstantin Karasyov0a613902007-02-16 01:47:06 -0500270 mutex_unlock(&resource->resource_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700271
Patrick Mochel5fbc19e2006-05-19 16:54:43 -0400272 status = acpi_evaluate_object(resource->device->handle, "_OFF", NULL, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700273 if (ACPI_FAILURE(status))
Patrick Mocheld550d982006-06-27 00:41:40 -0400274 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276 /* Update the power resource's _device_ power state */
Dmitry Torokhov786f18c2006-08-23 23:18:06 -0400277 resource->device->power.state = ACPI_STATE_D3;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278
279 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Resource [%s] turned off\n",
Len Brown4be44fc2005-08-05 00:44:28 -0400280 resource->name));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281
Patrick Mocheld550d982006-06-27 00:41:40 -0400282 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700283}
284
Rafael J. Wysocki77e76602008-07-07 03:33:34 +0200285/**
286 * acpi_device_sleep_wake - execute _DSW (Device Sleep Wake) or (deprecated in
287 * ACPI 3.0) _PSW (Power State Wake)
288 * @dev: Device to handle.
289 * @enable: 0 - disable, 1 - enable the wake capabilities of the device.
290 * @sleep_state: Target sleep state of the system.
291 * @dev_state: Target power state of the device.
292 *
293 * Execute _DSW (Device Sleep Wake) or (deprecated in ACPI 3.0) _PSW (Power
294 * State Wake) for the device, if present. On failure reset the device's
295 * wakeup.flags.valid flag.
296 *
297 * RETURN VALUE:
298 * 0 if either _DSW or _PSW has been successfully executed
299 * 0 if neither _DSW nor _PSW has been found
300 * -ENODEV if the execution of either _DSW or _PSW has failed
301 */
302int acpi_device_sleep_wake(struct acpi_device *dev,
303 int enable, int sleep_state, int dev_state)
304{
305 union acpi_object in_arg[3];
306 struct acpi_object_list arg_list = { 3, in_arg };
307 acpi_status status = AE_OK;
308
309 /*
310 * Try to execute _DSW first.
311 *
312 * Three agruments are needed for the _DSW object:
313 * Argument 0: enable/disable the wake capabilities
314 * Argument 1: target system state
315 * Argument 2: target device state
316 * When _DSW object is called to disable the wake capabilities, maybe
317 * the first argument is filled. The values of the other two agruments
318 * are meaningless.
319 */
320 in_arg[0].type = ACPI_TYPE_INTEGER;
321 in_arg[0].integer.value = enable;
322 in_arg[1].type = ACPI_TYPE_INTEGER;
323 in_arg[1].integer.value = sleep_state;
324 in_arg[2].type = ACPI_TYPE_INTEGER;
325 in_arg[2].integer.value = dev_state;
326 status = acpi_evaluate_object(dev->handle, "_DSW", &arg_list, NULL);
327 if (ACPI_SUCCESS(status)) {
328 return 0;
329 } else if (status != AE_NOT_FOUND) {
330 printk(KERN_ERR PREFIX "_DSW execution failed\n");
331 dev->wakeup.flags.valid = 0;
332 return -ENODEV;
333 }
334
335 /* Execute _PSW */
336 arg_list.count = 1;
337 in_arg[0].integer.value = enable;
338 status = acpi_evaluate_object(dev->handle, "_PSW", &arg_list, NULL);
339 if (ACPI_FAILURE(status) && (status != AE_NOT_FOUND)) {
340 printk(KERN_ERR PREFIX "_PSW execution failed\n");
341 dev->wakeup.flags.valid = 0;
342 return -ENODEV;
343 }
344
345 return 0;
346}
347
Linus Torvalds1da177e2005-04-16 15:20:36 -0700348/*
349 * Prepare a wakeup device, two steps (Ref ACPI 2.0:P229):
350 * 1. Power on the power resources required for the wakeup device
Rafael J. Wysocki77e76602008-07-07 03:33:34 +0200351 * 2. Execute _DSW (Device Sleep Wake) or (deprecated in ACPI 3.0) _PSW (Power
352 * State Wake) for the device, if present
Linus Torvalds1da177e2005-04-16 15:20:36 -0700353 */
Rafael J. Wysocki77e76602008-07-07 03:33:34 +0200354int acpi_enable_wakeup_device_power(struct acpi_device *dev, int sleep_state)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355{
Rafael J. Wysocki9b83ccd2009-09-08 23:15:31 +0200356 int i, err = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700357
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358 if (!dev || !dev->wakeup.flags.valid)
Rafael J. Wysocki77e76602008-07-07 03:33:34 +0200359 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700360
Rafael J. Wysocki9b83ccd2009-09-08 23:15:31 +0200361 mutex_lock(&acpi_device_lock);
362
363 if (dev->wakeup.prepare_count++)
364 goto out;
Rafael J. Wysocki0af4b8c2008-07-07 03:34:11 +0200365
Linus Torvalds1da177e2005-04-16 15:20:36 -0700366 /* Open power resource */
367 for (i = 0; i < dev->wakeup.resources.count; i++) {
Rafael J. Wysocki77e76602008-07-07 03:33:34 +0200368 int ret = acpi_power_on(dev->wakeup.resources.handles[i], dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369 if (ret) {
Len Brown64684632006-06-26 23:41:38 -0400370 printk(KERN_ERR PREFIX "Transition power state\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371 dev->wakeup.flags.valid = 0;
Rafael J. Wysocki9b83ccd2009-09-08 23:15:31 +0200372 err = -ENODEV;
373 goto err_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374 }
375 }
376
Rafael J. Wysocki77e76602008-07-07 03:33:34 +0200377 /*
378 * Passing 3 as the third argument below means the device may be placed
379 * in arbitrary power state afterwards.
380 */
Rafael J. Wysocki0af4b8c2008-07-07 03:34:11 +0200381 err = acpi_device_sleep_wake(dev, 1, sleep_state, 3);
Rafael J. Wysocki0af4b8c2008-07-07 03:34:11 +0200382
Rafael J. Wysocki9b83ccd2009-09-08 23:15:31 +0200383 err_out:
384 if (err)
385 dev->wakeup.prepare_count = 0;
386
387 out:
388 mutex_unlock(&acpi_device_lock);
Rafael J. Wysocki0af4b8c2008-07-07 03:34:11 +0200389 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390}
391
392/*
393 * Shutdown a wakeup device, counterpart of above method
Rafael J. Wysocki77e76602008-07-07 03:33:34 +0200394 * 1. Execute _DSW (Device Sleep Wake) or (deprecated in ACPI 3.0) _PSW (Power
395 * State Wake) for the device, if present
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396 * 2. Shutdown down the power resources
397 */
Len Brown4be44fc2005-08-05 00:44:28 -0400398int acpi_disable_wakeup_device_power(struct acpi_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399{
Rafael J. Wysocki9b83ccd2009-09-08 23:15:31 +0200400 int i, err = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700401
402 if (!dev || !dev->wakeup.flags.valid)
Rafael J. Wysocki77e76602008-07-07 03:33:34 +0200403 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700404
Rafael J. Wysocki9b83ccd2009-09-08 23:15:31 +0200405 mutex_lock(&acpi_device_lock);
406
407 if (--dev->wakeup.prepare_count > 0)
408 goto out;
409
Rafael J. Wysocki0af4b8c2008-07-07 03:34:11 +0200410 /*
Rafael J. Wysocki9b83ccd2009-09-08 23:15:31 +0200411 * Executing the code below even if prepare_count is already zero when
412 * the function is called may be useful, for example for initialisation.
Rafael J. Wysocki0af4b8c2008-07-07 03:34:11 +0200413 */
Rafael J. Wysocki9b83ccd2009-09-08 23:15:31 +0200414 if (dev->wakeup.prepare_count < 0)
415 dev->wakeup.prepare_count = 0;
Rafael J. Wysocki0af4b8c2008-07-07 03:34:11 +0200416
Rafael J. Wysocki9b83ccd2009-09-08 23:15:31 +0200417 err = acpi_device_sleep_wake(dev, 0, 0, 0);
418 if (err)
419 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420
421 /* Close power resource */
422 for (i = 0; i < dev->wakeup.resources.count; i++) {
Rafael J. Wysocki9b83ccd2009-09-08 23:15:31 +0200423 int ret = acpi_power_off_device(
424 dev->wakeup.resources.handles[i], dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425 if (ret) {
Len Brown64684632006-06-26 23:41:38 -0400426 printk(KERN_ERR PREFIX "Transition power state\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427 dev->wakeup.flags.valid = 0;
Rafael J. Wysocki9b83ccd2009-09-08 23:15:31 +0200428 err = -ENODEV;
429 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700430 }
431 }
432
Rafael J. Wysocki9b83ccd2009-09-08 23:15:31 +0200433 out:
434 mutex_unlock(&acpi_device_lock);
435 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700436}
437
438/* --------------------------------------------------------------------------
439 Device Power Management
440 -------------------------------------------------------------------------- */
441
Len Brown4be44fc2005-08-05 00:44:28 -0400442int acpi_power_get_inferred_state(struct acpi_device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700443{
Len Brown4be44fc2005-08-05 00:44:28 -0400444 int result = 0;
445 struct acpi_handle_list *list = NULL;
446 int list_state = 0;
447 int i = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449
450 if (!device)
Patrick Mocheld550d982006-06-27 00:41:40 -0400451 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452
453 device->power.state = ACPI_STATE_UNKNOWN;
454
455 /*
456 * We know a device's inferred power state when all the resources
457 * required for a given D-state are 'on'.
458 */
Len Brown4be44fc2005-08-05 00:44:28 -0400459 for (i = ACPI_STATE_D0; i < ACPI_STATE_D3; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700460 list = &device->power.states[i].resources;
461 if (list->count < 1)
462 continue;
463
464 result = acpi_power_get_list_state(list, &list_state);
465 if (result)
Patrick Mocheld550d982006-06-27 00:41:40 -0400466 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700467
468 if (list_state == ACPI_POWER_RESOURCE_STATE_ON) {
469 device->power.state = i;
Patrick Mocheld550d982006-06-27 00:41:40 -0400470 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700471 }
472 }
473
474 device->power.state = ACPI_STATE_D3;
475
Patrick Mocheld550d982006-06-27 00:41:40 -0400476 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700477}
478
Len Brown4be44fc2005-08-05 00:44:28 -0400479int acpi_power_transition(struct acpi_device *device, int state)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480{
Len Brown4be44fc2005-08-05 00:44:28 -0400481 int result = 0;
482 struct acpi_handle_list *cl = NULL; /* Current Resources */
483 struct acpi_handle_list *tl = NULL; /* Target Resources */
484 int i = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700485
Linus Torvalds1da177e2005-04-16 15:20:36 -0700486
487 if (!device || (state < ACPI_STATE_D0) || (state > ACPI_STATE_D3))
Patrick Mocheld550d982006-06-27 00:41:40 -0400488 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700489
Len Brown4be44fc2005-08-05 00:44:28 -0400490 if ((device->power.state < ACPI_STATE_D0)
491 || (device->power.state > ACPI_STATE_D3))
Patrick Mocheld550d982006-06-27 00:41:40 -0400492 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493
494 cl = &device->power.states[device->power.state].resources;
495 tl = &device->power.states[state].resources;
496
Linus Torvalds1da177e2005-04-16 15:20:36 -0700497 /* TBD: Resources must be ordered. */
498
499 /*
500 * First we reference all power resources required in the target list
501 * (e.g. so the device doesn't lose power while transitioning).
502 */
Len Brown4be44fc2005-08-05 00:44:28 -0400503 for (i = 0; i < tl->count; i++) {
Konstantin Karasyov0a613902007-02-16 01:47:06 -0500504 result = acpi_power_on(tl->handles[i], device);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700505 if (result)
506 goto end;
507 }
508
Konstantin Karasyovb1028c52007-02-16 02:23:07 -0500509 if (device->power.state == state) {
510 goto end;
511 }
512
Linus Torvalds1da177e2005-04-16 15:20:36 -0700513 /*
514 * Then we dereference all power resources used in the current list.
515 */
Len Brown4be44fc2005-08-05 00:44:28 -0400516 for (i = 0; i < cl->count; i++) {
Konstantin Karasyov0a613902007-02-16 01:47:06 -0500517 result = acpi_power_off_device(cl->handles[i], device);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700518 if (result)
519 goto end;
520 }
521
Konstantin Karasyov72925762007-02-21 02:05:58 -0500522 end:
Miguel Botóne76d5f72008-02-04 23:31:19 -0800523 if (result)
Konstantin Karasyov72925762007-02-21 02:05:58 -0500524 device->power.state = ACPI_STATE_UNKNOWN;
Miguel Botóne76d5f72008-02-04 23:31:19 -0800525 else {
Konstantin Karasyov72925762007-02-21 02:05:58 -0500526 /* We shouldn't change the state till all above operations succeed */
527 device->power.state = state;
528 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700529
Patrick Mocheld550d982006-06-27 00:41:40 -0400530 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531}
532
Linus Torvalds1da177e2005-04-16 15:20:36 -0700533/* --------------------------------------------------------------------------
Linus Torvalds1da177e2005-04-16 15:20:36 -0700534 Driver Interface
535 -------------------------------------------------------------------------- */
536
Len Brown4be44fc2005-08-05 00:44:28 -0400537static int acpi_power_add(struct acpi_device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538{
Alexey Starikovskiyc35923b2007-10-22 14:19:09 +0400539 int result = 0, state;
Len Brown4be44fc2005-08-05 00:44:28 -0400540 acpi_status status = AE_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700541 struct acpi_power_resource *resource = NULL;
Len Brown4be44fc2005-08-05 00:44:28 -0400542 union acpi_object acpi_object;
543 struct acpi_buffer buffer = { sizeof(acpi_object), &acpi_object };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700544
Linus Torvalds1da177e2005-04-16 15:20:36 -0700545
546 if (!device)
Patrick Mocheld550d982006-06-27 00:41:40 -0400547 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700548
Burman Yan36bcbec2006-12-19 12:56:11 -0800549 resource = kzalloc(sizeof(struct acpi_power_resource), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700550 if (!resource)
Patrick Mocheld550d982006-06-27 00:41:40 -0400551 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700552
Patrick Mochel41598572006-05-19 16:54:40 -0400553 resource->device = device;
Konstantin Karasyov0a613902007-02-16 01:47:06 -0500554 mutex_init(&resource->resource_lock);
555 INIT_LIST_HEAD(&resource->reference);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700556 strcpy(resource->name, device->pnp.bus_id);
557 strcpy(acpi_device_name(device), ACPI_POWER_DEVICE_NAME);
558 strcpy(acpi_device_class(device), ACPI_POWER_CLASS);
Pavel Machekdb89b4f2008-09-22 14:37:34 -0700559 device->driver_data = resource;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700560
561 /* Evalute the object to get the system level and resource order. */
Patrick Mochel5fbc19e2006-05-19 16:54:43 -0400562 status = acpi_evaluate_object(device->handle, NULL, NULL, &buffer);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700563 if (ACPI_FAILURE(status)) {
564 result = -ENODEV;
565 goto end;
566 }
567 resource->system_level = acpi_object.power_resource.system_level;
568 resource->order = acpi_object.power_resource.resource_order;
569
Zhao Yakuia51e1452008-08-11 14:55:05 +0800570 result = acpi_power_get_state(device->handle, &state);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700571 if (result)
572 goto end;
573
Alexey Starikovskiyc35923b2007-10-22 14:19:09 +0400574 switch (state) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575 case ACPI_POWER_RESOURCE_STATE_ON:
576 device->power.state = ACPI_STATE_D0;
577 break;
578 case ACPI_POWER_RESOURCE_STATE_OFF:
579 device->power.state = ACPI_STATE_D3;
580 break;
581 default:
582 device->power.state = ACPI_STATE_UNKNOWN;
583 break;
584 }
585
Len Brown4be44fc2005-08-05 00:44:28 -0400586 printk(KERN_INFO PREFIX "%s [%s] (%s)\n", acpi_device_name(device),
Alexey Starikovskiyc35923b2007-10-22 14:19:09 +0400587 acpi_device_bid(device), state ? "on" : "off");
Len Brown4be44fc2005-08-05 00:44:28 -0400588
589 end:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700590 if (result)
591 kfree(resource);
Len Brown4be44fc2005-08-05 00:44:28 -0400592
Patrick Mocheld550d982006-06-27 00:41:40 -0400593 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700594}
595
Len Brown4be44fc2005-08-05 00:44:28 -0400596static int acpi_power_remove(struct acpi_device *device, int type)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700597{
598 struct acpi_power_resource *resource = NULL;
Konstantin Karasyov0a613902007-02-16 01:47:06 -0500599 struct list_head *node, *next;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700600
Linus Torvalds1da177e2005-04-16 15:20:36 -0700601
602 if (!device || !acpi_driver_data(device))
Patrick Mocheld550d982006-06-27 00:41:40 -0400603 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700604
Jan Engelhardt50dd0962006-10-01 00:28:50 +0200605 resource = acpi_driver_data(device);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700606
Konstantin Karasyov0a613902007-02-16 01:47:06 -0500607 mutex_lock(&resource->resource_lock);
608 list_for_each_safe(node, next, &resource->reference) {
609 struct acpi_power_reference *ref = container_of(node, struct acpi_power_reference, node);
610 list_del(&ref->node);
611 kfree(ref);
612 }
613 mutex_unlock(&resource->resource_lock);
614
Linus Torvalds1da177e2005-04-16 15:20:36 -0700615 kfree(resource);
616
Patrick Mocheld550d982006-06-27 00:41:40 -0400617 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700618}
619
Len Browne8363f32007-02-16 02:05:39 -0500620static int acpi_power_resume(struct acpi_device *device)
Konstantin Karasyov0a613902007-02-16 01:47:06 -0500621{
Alexey Starikovskiyc35923b2007-10-22 14:19:09 +0400622 int result = 0, state;
Konstantin Karasyov0a613902007-02-16 01:47:06 -0500623 struct acpi_power_resource *resource = NULL;
624 struct acpi_power_reference *ref;
625
626 if (!device || !acpi_driver_data(device))
627 return -EINVAL;
628
Pavel Machekdb89b4f2008-09-22 14:37:34 -0700629 resource = acpi_driver_data(device);
Konstantin Karasyov0a613902007-02-16 01:47:06 -0500630
Zhao Yakuia51e1452008-08-11 14:55:05 +0800631 result = acpi_power_get_state(device->handle, &state);
Konstantin Karasyov0a613902007-02-16 01:47:06 -0500632 if (result)
633 return result;
634
635 mutex_lock(&resource->resource_lock);
Alexey Starikovskiyc35923b2007-10-22 14:19:09 +0400636 if (state == ACPI_POWER_RESOURCE_STATE_OFF &&
Konstantin Karasyov0a613902007-02-16 01:47:06 -0500637 !list_empty(&resource->reference)) {
638 ref = container_of(resource->reference.next, struct acpi_power_reference, node);
639 mutex_unlock(&resource->resource_lock);
640 result = acpi_power_on(device->handle, ref->device);
641 return result;
642 }
643
644 mutex_unlock(&resource->resource_lock);
645 return 0;
646}
647
Bjorn Helgaas44515372009-03-24 16:49:53 -0600648int __init acpi_power_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700649{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700650 INIT_LIST_HEAD(&acpi_power_resource_list);
Zhang Rui06af7eb2010-07-15 10:46:38 +0800651 return acpi_bus_register_driver(&acpi_power_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700652}