blob: a94383d1f3502ae35138e7e677df02c1d8df3d72 [file] [log] [blame]
Rafael J. Wysockiec2cd812012-11-02 01:40:09 +01001/*
2 * drivers/acpi/device_pm.c - ACPI device power management routines.
3 *
4 * Copyright (C) 2012, Intel Corp.
5 * Author: Rafael J. Wysocki <rafael.j.wysocki@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 version 2 as published
11 * by the Free Software Foundation.
12 *
13 * This program is distributed in the hope that it will be useful, but
14 * WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License along
19 * with this program; if not, write to the Free Software Foundation, Inc.,
20 * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
21 *
22 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
23 */
24
25#include <linux/device.h>
Rafael J. Wysocki86b38322012-11-02 01:40:18 +010026#include <linux/export.h>
Rafael J. Wysockiec2cd812012-11-02 01:40:09 +010027#include <linux/mutex.h>
Rafael J. Wysocki86b38322012-11-02 01:40:18 +010028#include <linux/pm_qos.h>
Rafael J. Wysockicd7bd022012-11-02 01:40:28 +010029#include <linux/pm_runtime.h>
Rafael J. Wysockiec2cd812012-11-02 01:40:09 +010030
31#include <acpi/acpi.h>
32#include <acpi/acpi_bus.h>
Rafael J. Wysocki9ce4e602013-01-17 14:11:08 +010033#include <acpi/acpi_drivers.h>
34
35#include "internal.h"
36
37#define _COMPONENT ACPI_POWER_COMPONENT
38ACPI_MODULE_NAME("device_pm");
Rafael J. Wysockiec2cd812012-11-02 01:40:09 +010039
Rafael J. Wysocki86b38322012-11-02 01:40:18 +010040/**
Rafael J. Wysocki9ce4e602013-01-17 14:11:08 +010041 * acpi_power_state_string - String representation of ACPI device power state.
42 * @state: ACPI device power state to return the string representation of.
43 */
44const char *acpi_power_state_string(int state)
45{
46 switch (state) {
47 case ACPI_STATE_D0:
48 return "D0";
49 case ACPI_STATE_D1:
50 return "D1";
51 case ACPI_STATE_D2:
52 return "D2";
53 case ACPI_STATE_D3_HOT:
54 return "D3hot";
55 case ACPI_STATE_D3_COLD:
Rafael J. Wysocki898fee42013-01-22 12:56:26 +010056 return "D3cold";
Rafael J. Wysocki9ce4e602013-01-17 14:11:08 +010057 default:
58 return "(unknown)";
59 }
60}
61
62/**
63 * acpi_device_get_power - Get power state of an ACPI device.
64 * @device: Device to get the power state of.
65 * @state: Place to store the power state of the device.
66 *
67 * This function does not update the device's power.state field, but it may
68 * update its parent's power.state field (when the parent's power state is
69 * unknown and the device's power state turns out to be D0).
70 */
71int acpi_device_get_power(struct acpi_device *device, int *state)
72{
73 int result = ACPI_STATE_UNKNOWN;
74
75 if (!device || !state)
76 return -EINVAL;
77
78 if (!device->flags.power_manageable) {
79 /* TBD: Non-recursive algorithm for walking up hierarchy. */
80 *state = device->parent ?
81 device->parent->power.state : ACPI_STATE_D0;
82 goto out;
83 }
84
85 /*
Rafael J. Wysocki75eb2d12013-03-24 22:54:40 +010086 * Get the device's power state from power resources settings and _PSC,
87 * if available.
Rafael J. Wysocki9ce4e602013-01-17 14:11:08 +010088 */
Rafael J. Wysocki75eb2d12013-03-24 22:54:40 +010089 if (device->power.flags.power_resources) {
Rafael J. Wysocki9ce4e602013-01-17 14:11:08 +010090 int error = acpi_power_get_inferred_state(device, &result);
91 if (error)
92 return error;
Rafael J. Wysocki75eb2d12013-03-24 22:54:40 +010093 }
94 if (device->power.flags.explicit_get) {
95 acpi_handle handle = device->handle;
96 unsigned long long psc;
97 acpi_status status;
98
99 status = acpi_evaluate_integer(handle, "_PSC", NULL, &psc);
100 if (ACPI_FAILURE(status))
101 return -ENODEV;
102
103 /*
104 * The power resources settings may indicate a power state
105 * shallower than the actual power state of the device.
106 *
107 * Moreover, on systems predating ACPI 4.0, if the device
108 * doesn't depend on any power resources and _PSC returns 3,
109 * that means "power off". We need to maintain compatibility
110 * with those systems.
111 */
112 if (psc > result && psc < ACPI_STATE_D3_COLD)
113 result = psc;
114 else if (result == ACPI_STATE_UNKNOWN)
115 result = psc > ACPI_STATE_D2 ? ACPI_STATE_D3_COLD : psc;
Rafael J. Wysocki9ce4e602013-01-17 14:11:08 +0100116 }
117
118 /*
119 * If we were unsure about the device parent's power state up to this
120 * point, the fact that the device is in D0 implies that the parent has
121 * to be in D0 too.
122 */
123 if (device->parent && device->parent->power.state == ACPI_STATE_UNKNOWN
124 && result == ACPI_STATE_D0)
125 device->parent->power.state = ACPI_STATE_D0;
126
127 *state = result;
128
129 out:
130 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device [%s] power state is %s\n",
131 device->pnp.bus_id, acpi_power_state_string(*state)));
132
133 return 0;
134}
135
Rafael J. Wysocki9c0f45e2013-01-22 12:55:52 +0100136static int acpi_dev_pm_explicit_set(struct acpi_device *adev, int state)
137{
138 if (adev->power.states[state].flags.explicit_set) {
139 char method[5] = { '_', 'P', 'S', '0' + state, '\0' };
140 acpi_status status;
141
142 status = acpi_evaluate_object(adev->handle, method, NULL, NULL);
143 if (ACPI_FAILURE(status))
144 return -ENODEV;
145 }
146 return 0;
147}
148
Rafael J. Wysocki9ce4e602013-01-17 14:11:08 +0100149/**
150 * acpi_device_set_power - Set power state of an ACPI device.
151 * @device: Device to set the power state of.
152 * @state: New power state to set.
153 *
154 * Callers must ensure that the device is power manageable before using this
155 * function.
156 */
157int acpi_device_set_power(struct acpi_device *device, int state)
158{
159 int result = 0;
Rafael J. Wysocki9ce4e602013-01-17 14:11:08 +0100160 bool cut_power = false;
161
Rafael J. Wysocki2c7d1322013-07-30 14:34:00 +0200162 if (!device || !device->flags.power_manageable
163 || (state < ACPI_STATE_D0) || (state > ACPI_STATE_D3_COLD))
Rafael J. Wysocki9ce4e602013-01-17 14:11:08 +0100164 return -EINVAL;
165
166 /* Make sure this is a valid target state */
167
168 if (state == device->power.state) {
Rafael J. Wysockib69137a2013-07-30 14:34:55 +0200169 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device [%s] already in %s\n",
170 device->pnp.bus_id,
Rafael J. Wysocki9ce4e602013-01-17 14:11:08 +0100171 acpi_power_state_string(state)));
172 return 0;
173 }
174
175 if (!device->power.states[state].flags.valid) {
Rafael J. Wysockib69137a2013-07-30 14:34:55 +0200176 dev_warn(&device->dev, "Power state %s not supported\n",
177 acpi_power_state_string(state));
Rafael J. Wysocki9ce4e602013-01-17 14:11:08 +0100178 return -ENODEV;
179 }
180 if (device->parent && (state < device->parent->power.state)) {
Rafael J. Wysockib69137a2013-07-30 14:34:55 +0200181 dev_warn(&device->dev,
Aaron Lu593298e2013-08-03 21:13:22 +0200182 "Cannot transition to power state %s for parent in %s\n",
183 acpi_power_state_string(state),
184 acpi_power_state_string(device->parent->power.state));
Rafael J. Wysocki9ce4e602013-01-17 14:11:08 +0100185 return -ENODEV;
186 }
187
188 /* For D3cold we should first transition into D3hot. */
189 if (state == ACPI_STATE_D3_COLD
190 && device->power.states[ACPI_STATE_D3_COLD].flags.os_accessible) {
191 state = ACPI_STATE_D3_HOT;
Rafael J. Wysocki9ce4e602013-01-17 14:11:08 +0100192 cut_power = true;
193 }
194
Rafael J. Wysockie78adb72013-01-22 12:56:04 +0100195 if (state < device->power.state && state != ACPI_STATE_D0
196 && device->power.state >= ACPI_STATE_D3_HOT) {
Rafael J. Wysockib69137a2013-07-30 14:34:55 +0200197 dev_warn(&device->dev,
198 "Cannot transition to non-D0 state from D3\n");
Rafael J. Wysockie78adb72013-01-22 12:56:04 +0100199 return -ENODEV;
200 }
201
Rafael J. Wysocki9ce4e602013-01-17 14:11:08 +0100202 /*
203 * Transition Power
204 * ----------------
Rafael J. Wysockie78adb72013-01-22 12:56:04 +0100205 * In accordance with the ACPI specification first apply power (via
206 * power resources) and then evalute _PSx.
Rafael J. Wysocki9ce4e602013-01-17 14:11:08 +0100207 */
Rafael J. Wysockie78adb72013-01-22 12:56:04 +0100208 if (device->power.flags.power_resources) {
209 result = acpi_power_transition(device, state);
Rafael J. Wysocki9c0f45e2013-01-22 12:55:52 +0100210 if (result)
211 goto end;
Rafael J. Wysocki9ce4e602013-01-17 14:11:08 +0100212 }
Rafael J. Wysockie78adb72013-01-22 12:56:04 +0100213 result = acpi_dev_pm_explicit_set(device, state);
214 if (result)
215 goto end;
Rafael J. Wysocki9ce4e602013-01-17 14:11:08 +0100216
Rafael J. Wysockie5656272013-01-22 12:56:35 +0100217 if (cut_power) {
218 device->power.state = state;
219 state = ACPI_STATE_D3_COLD;
220 result = acpi_power_transition(device, state);
221 }
Rafael J. Wysocki9ce4e602013-01-17 14:11:08 +0100222
Rafael J. Wysockie78adb72013-01-22 12:56:04 +0100223 end:
224 if (result) {
Rafael J. Wysockib69137a2013-07-30 14:34:55 +0200225 dev_warn(&device->dev, "Failed to change power state to %s\n",
226 acpi_power_state_string(state));
Rafael J. Wysockie78adb72013-01-22 12:56:04 +0100227 } else {
Rafael J. Wysocki9ce4e602013-01-17 14:11:08 +0100228 device->power.state = state;
229 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
230 "Device [%s] transitioned to %s\n",
231 device->pnp.bus_id,
232 acpi_power_state_string(state)));
233 }
234
235 return result;
236}
237EXPORT_SYMBOL(acpi_device_set_power);
238
239int acpi_bus_set_power(acpi_handle handle, int state)
240{
241 struct acpi_device *device;
242 int result;
243
244 result = acpi_bus_get_device(handle, &device);
245 if (result)
246 return result;
247
Rafael J. Wysocki9ce4e602013-01-17 14:11:08 +0100248 return acpi_device_set_power(device, state);
249}
250EXPORT_SYMBOL(acpi_bus_set_power);
251
252int acpi_bus_init_power(struct acpi_device *device)
253{
254 int state;
255 int result;
256
257 if (!device)
258 return -EINVAL;
259
260 device->power.state = ACPI_STATE_UNKNOWN;
261
262 result = acpi_device_get_power(device, &state);
263 if (result)
264 return result;
265
Rafael J. Wysockia2367802013-01-22 12:54:38 +0100266 if (state < ACPI_STATE_D3_COLD && device->power.flags.power_resources) {
Rafael J. Wysocki9ce4e602013-01-17 14:11:08 +0100267 result = acpi_power_on_resources(device, state);
Rafael J. Wysockia2367802013-01-22 12:54:38 +0100268 if (result)
269 return result;
Rafael J. Wysocki9ce4e602013-01-17 14:11:08 +0100270
Rafael J. Wysocki9c0f45e2013-01-22 12:55:52 +0100271 result = acpi_dev_pm_explicit_set(device, state);
272 if (result)
273 return result;
Rafael J. Wysockib3785492013-02-01 23:43:02 +0100274 } else if (state == ACPI_STATE_UNKNOWN) {
Rafael J. Wysocki7cd84072013-06-05 14:01:19 +0200275 /*
276 * No power resources and missing _PSC? Cross fingers and make
277 * it D0 in hope that this is what the BIOS put the device into.
278 * [We tried to force D0 here by executing _PS0, but that broke
279 * Toshiba P870-303 in a nasty way.]
280 */
Rafael J. Wysockib3785492013-02-01 23:43:02 +0100281 state = ACPI_STATE_D0;
Rafael J. Wysockia2367802013-01-22 12:54:38 +0100282 }
283 device->power.state = state;
284 return 0;
Rafael J. Wysocki9ce4e602013-01-17 14:11:08 +0100285}
286
Rafael J. Wysockib9e95fc2013-06-19 00:45:34 +0200287/**
288 * acpi_device_fix_up_power - Force device with missing _PSC into D0.
289 * @device: Device object whose power state is to be fixed up.
290 *
291 * Devices without power resources and _PSC, but having _PS0 and _PS3 defined,
292 * are assumed to be put into D0 by the BIOS. However, in some cases that may
293 * not be the case and this function should be used then.
294 */
295int acpi_device_fix_up_power(struct acpi_device *device)
296{
297 int ret = 0;
298
299 if (!device->power.flags.power_resources
300 && !device->power.flags.explicit_get
301 && device->power.state == ACPI_STATE_D0)
302 ret = acpi_dev_pm_explicit_set(device, ACPI_STATE_D0);
303
304 return ret;
305}
306
Rafael J. Wysocki9ce4e602013-01-17 14:11:08 +0100307int acpi_bus_update_power(acpi_handle handle, int *state_p)
308{
309 struct acpi_device *device;
310 int state;
311 int result;
312
313 result = acpi_bus_get_device(handle, &device);
314 if (result)
315 return result;
316
317 result = acpi_device_get_power(device, &state);
318 if (result)
319 return result;
320
Rafael J. Wysocki91bdad02013-07-04 13:22:11 +0200321 if (state == ACPI_STATE_UNKNOWN) {
Rafael J. Wysocki511d5c42013-02-03 14:57:32 +0100322 state = ACPI_STATE_D0;
Rafael J. Wysocki91bdad02013-07-04 13:22:11 +0200323 result = acpi_device_set_power(device, state);
324 if (result)
325 return result;
326 } else {
327 if (device->power.flags.power_resources) {
328 /*
329 * We don't need to really switch the state, bu we need
330 * to update the power resources' reference counters.
331 */
332 result = acpi_power_transition(device, state);
333 if (result)
334 return result;
335 }
336 device->power.state = state;
337 }
338 if (state_p)
Rafael J. Wysocki9ce4e602013-01-17 14:11:08 +0100339 *state_p = state;
340
Rafael J. Wysocki91bdad02013-07-04 13:22:11 +0200341 return 0;
Rafael J. Wysocki9ce4e602013-01-17 14:11:08 +0100342}
343EXPORT_SYMBOL_GPL(acpi_bus_update_power);
344
345bool acpi_bus_power_manageable(acpi_handle handle)
346{
347 struct acpi_device *device;
348 int result;
349
350 result = acpi_bus_get_device(handle, &device);
351 return result ? false : device->flags.power_manageable;
352}
353EXPORT_SYMBOL(acpi_bus_power_manageable);
354
Rafael J. Wysockiec4602a2013-05-16 22:29:28 +0200355#ifdef CONFIG_PM
356static DEFINE_MUTEX(acpi_pm_notifier_lock);
357
358/**
359 * acpi_add_pm_notifier - Register PM notifier for given ACPI device.
360 * @adev: ACPI device to add the notifier for.
361 * @context: Context information to pass to the notifier routine.
362 *
363 * NOTE: @adev need not be a run-wake or wakeup device to be a valid source of
364 * PM wakeup events. For example, wakeup events may be generated for bridges
365 * if one of the devices below the bridge is signaling wakeup, even if the
366 * bridge itself doesn't have a wakeup GPE associated with it.
367 */
368acpi_status acpi_add_pm_notifier(struct acpi_device *adev,
369 acpi_notify_handler handler, void *context)
370{
371 acpi_status status = AE_ALREADY_EXISTS;
372
373 mutex_lock(&acpi_pm_notifier_lock);
374
375 if (adev->wakeup.flags.notifier_present)
376 goto out;
377
378 status = acpi_install_notify_handler(adev->handle,
379 ACPI_SYSTEM_NOTIFY,
380 handler, context);
381 if (ACPI_FAILURE(status))
382 goto out;
383
384 adev->wakeup.flags.notifier_present = true;
385
386 out:
387 mutex_unlock(&acpi_pm_notifier_lock);
388 return status;
389}
390
391/**
392 * acpi_remove_pm_notifier - Unregister PM notifier from given ACPI device.
393 * @adev: ACPI device to remove the notifier from.
394 */
395acpi_status acpi_remove_pm_notifier(struct acpi_device *adev,
396 acpi_notify_handler handler)
397{
398 acpi_status status = AE_BAD_PARAMETER;
399
400 mutex_lock(&acpi_pm_notifier_lock);
401
402 if (!adev->wakeup.flags.notifier_present)
403 goto out;
404
405 status = acpi_remove_notify_handler(adev->handle,
406 ACPI_SYSTEM_NOTIFY,
407 handler);
408 if (ACPI_FAILURE(status))
409 goto out;
410
411 adev->wakeup.flags.notifier_present = false;
412
413 out:
414 mutex_unlock(&acpi_pm_notifier_lock);
415 return status;
416}
417
Rafael J. Wysocki9ce4e602013-01-17 14:11:08 +0100418bool acpi_bus_can_wakeup(acpi_handle handle)
419{
420 struct acpi_device *device;
421 int result;
422
423 result = acpi_bus_get_device(handle, &device);
424 return result ? false : device->wakeup.flags.valid;
425}
426EXPORT_SYMBOL(acpi_bus_can_wakeup);
427
428/**
Rafael J. Wysockib25c77e2013-06-16 00:37:42 +0200429 * acpi_dev_pm_get_state - Get preferred power state of ACPI device.
Rafael J. Wysocki86b38322012-11-02 01:40:18 +0100430 * @dev: Device whose preferred target power state to return.
431 * @adev: ACPI device node corresponding to @dev.
432 * @target_state: System state to match the resultant device state.
Rafael J. Wysockifa1675b2013-06-16 00:37:59 +0200433 * @d_min_p: Location to store the highest power state available to the device.
434 * @d_max_p: Location to store the lowest power state available to the device.
Rafael J. Wysocki86b38322012-11-02 01:40:18 +0100435 *
Rafael J. Wysockifa1675b2013-06-16 00:37:59 +0200436 * Find the lowest power (highest number) and highest power (lowest number) ACPI
437 * device power states that the device can be in while the system is in the
438 * state represented by @target_state. Store the integer numbers representing
439 * those stats in the memory locations pointed to by @d_max_p and @d_min_p,
440 * respectively.
Rafael J. Wysocki86b38322012-11-02 01:40:18 +0100441 *
442 * Callers must ensure that @dev and @adev are valid pointers and that @adev
443 * actually corresponds to @dev before using this function.
Rafael J. Wysockifa1675b2013-06-16 00:37:59 +0200444 *
445 * Returns 0 on success or -ENODATA when one of the ACPI methods fails or
446 * returns a value that doesn't make sense. The memory locations pointed to by
447 * @d_max_p and @d_min_p are only modified on success.
Rafael J. Wysocki86b38322012-11-02 01:40:18 +0100448 */
Rafael J. Wysockib25c77e2013-06-16 00:37:42 +0200449static int acpi_dev_pm_get_state(struct device *dev, struct acpi_device *adev,
Rafael J. Wysockifa1675b2013-06-16 00:37:59 +0200450 u32 target_state, int *d_min_p, int *d_max_p)
Rafael J. Wysocki86b38322012-11-02 01:40:18 +0100451{
Rafael J. Wysockifa1675b2013-06-16 00:37:59 +0200452 char method[] = { '_', 'S', '0' + target_state, 'D', '\0' };
453 acpi_handle handle = adev->handle;
454 unsigned long long ret;
455 int d_min, d_max;
Rafael J. Wysocki86b38322012-11-02 01:40:18 +0100456 bool wakeup = false;
Rafael J. Wysockifa1675b2013-06-16 00:37:59 +0200457 acpi_status status;
Rafael J. Wysocki86b38322012-11-02 01:40:18 +0100458
Rafael J. Wysocki86b38322012-11-02 01:40:18 +0100459 /*
Rafael J. Wysockifa1675b2013-06-16 00:37:59 +0200460 * If the system state is S0, the lowest power state the device can be
461 * in is D3cold, unless the device has _S0W and is supposed to signal
462 * wakeup, in which case the return value of _S0W has to be used as the
463 * lowest power state available to the device.
Rafael J. Wysocki86b38322012-11-02 01:40:18 +0100464 */
465 d_min = ACPI_STATE_D0;
Rafael J. Wysocki4c164ae2013-06-16 00:37:50 +0200466 d_max = ACPI_STATE_D3_COLD;
Rafael J. Wysocki86b38322012-11-02 01:40:18 +0100467
468 /*
469 * If present, _SxD methods return the minimum D-state (highest power
470 * state) we can use for the corresponding S-states. Otherwise, the
471 * minimum D-state is D0 (ACPI 3.x).
Rafael J. Wysocki86b38322012-11-02 01:40:18 +0100472 */
473 if (target_state > ACPI_STATE_S0) {
Rafael J. Wysockifa1675b2013-06-16 00:37:59 +0200474 /*
475 * We rely on acpi_evaluate_integer() not clobbering the integer
476 * provided if AE_NOT_FOUND is returned.
477 */
478 ret = d_min;
479 status = acpi_evaluate_integer(handle, method, NULL, &ret);
480 if ((ACPI_FAILURE(status) && status != AE_NOT_FOUND)
481 || ret > ACPI_STATE_D3_COLD)
482 return -ENODATA;
483
484 /*
485 * We need to handle legacy systems where D3hot and D3cold are
486 * the same and 3 is returned in both cases, so fall back to
487 * D3cold if D3hot is not a valid state.
488 */
489 if (!adev->power.states[ret].flags.valid) {
490 if (ret == ACPI_STATE_D3_HOT)
491 ret = ACPI_STATE_D3_COLD;
492 else
493 return -ENODATA;
494 }
495 d_min = ret;
Rafael J. Wysocki86b38322012-11-02 01:40:18 +0100496 wakeup = device_may_wakeup(dev) && adev->wakeup.flags.valid
497 && adev->wakeup.sleep_state >= target_state;
498 } else if (dev_pm_qos_flags(dev, PM_QOS_FLAG_REMOTE_WAKEUP) !=
499 PM_QOS_FLAGS_NONE) {
500 wakeup = adev->wakeup.flags.valid;
501 }
502
503 /*
504 * If _PRW says we can wake up the system from the target sleep state,
505 * the D-state returned by _SxD is sufficient for that (we assume a
506 * wakeup-aware driver if wake is set). Still, if _SxW exists
507 * (ACPI 3.x), it should return the maximum (lowest power) D-state that
508 * can wake the system. _S0W may be valid, too.
509 */
510 if (wakeup) {
Rafael J. Wysockifa1675b2013-06-16 00:37:59 +0200511 method[3] = 'W';
512 status = acpi_evaluate_integer(handle, method, NULL, &ret);
513 if (status == AE_NOT_FOUND) {
514 if (target_state > ACPI_STATE_S0)
Rafael J. Wysocki86b38322012-11-02 01:40:18 +0100515 d_max = d_min;
Rafael J. Wysockifa1675b2013-06-16 00:37:59 +0200516 } else if (ACPI_SUCCESS(status) && ret <= ACPI_STATE_D3_COLD) {
517 /* Fall back to D3cold if ret is not a valid state. */
518 if (!adev->power.states[ret].flags.valid)
519 ret = ACPI_STATE_D3_COLD;
520
521 d_max = ret > d_min ? ret : d_min;
522 } else {
523 return -ENODATA;
Rafael J. Wysocki86b38322012-11-02 01:40:18 +0100524 }
525 }
526
Rafael J. Wysocki86b38322012-11-02 01:40:18 +0100527 if (d_min_p)
528 *d_min_p = d_min;
Rafael J. Wysockifa1675b2013-06-16 00:37:59 +0200529
530 if (d_max_p)
531 *d_max_p = d_max;
532
533 return 0;
Rafael J. Wysocki86b38322012-11-02 01:40:18 +0100534}
Rafael J. Wysockicd7bd022012-11-02 01:40:28 +0100535
Rafael J. Wysockia6ae7592012-11-02 01:40:53 +0100536/**
537 * acpi_pm_device_sleep_state - Get preferred power state of ACPI device.
538 * @dev: Device whose preferred target power state to return.
539 * @d_min_p: Location to store the upper limit of the allowed states range.
540 * @d_max_in: Deepest low-power state to take into consideration.
541 * Return value: Preferred power state of the device on success, -ENODEV
Rafael J. Wysockifa1675b2013-06-16 00:37:59 +0200542 * if there's no 'struct acpi_device' for @dev, -EINVAL if @d_max_in is
543 * incorrect, or -ENODATA on ACPI method failure.
Rafael J. Wysockia6ae7592012-11-02 01:40:53 +0100544 *
545 * The caller must ensure that @dev is valid before using this function.
546 */
547int acpi_pm_device_sleep_state(struct device *dev, int *d_min_p, int d_max_in)
548{
549 acpi_handle handle = DEVICE_ACPI_HANDLE(dev);
550 struct acpi_device *adev;
Rafael J. Wysocki9b5c7a52013-06-27 14:01:02 +0200551 int ret, d_min, d_max;
Rafael J. Wysockifa1675b2013-06-16 00:37:59 +0200552
553 if (d_max_in < ACPI_STATE_D0 || d_max_in > ACPI_STATE_D3_COLD)
554 return -EINVAL;
555
556 if (d_max_in > ACPI_STATE_D3_HOT) {
557 enum pm_qos_flags_status stat;
558
559 stat = dev_pm_qos_flags(dev, PM_QOS_FLAG_NO_POWER_OFF);
560 if (stat == PM_QOS_FLAGS_ALL)
561 d_max_in = ACPI_STATE_D3_HOT;
562 }
Rafael J. Wysockia6ae7592012-11-02 01:40:53 +0100563
Yasuaki Ishimatsudde3bb42013-01-31 03:22:14 +0000564 if (!handle || acpi_bus_get_device(handle, &adev)) {
Rafael J. Wysockia6ae7592012-11-02 01:40:53 +0100565 dev_dbg(dev, "ACPI handle without context in %s!\n", __func__);
566 return -ENODEV;
567 }
568
Rafael J. Wysockifa1675b2013-06-16 00:37:59 +0200569 ret = acpi_dev_pm_get_state(dev, adev, acpi_target_system_state(),
Rafael J. Wysocki9b5c7a52013-06-27 14:01:02 +0200570 &d_min, &d_max);
Rafael J. Wysockifa1675b2013-06-16 00:37:59 +0200571 if (ret)
572 return ret;
573
Rafael J. Wysocki9b5c7a52013-06-27 14:01:02 +0200574 if (d_max_in < d_min)
Rafael J. Wysockifa1675b2013-06-16 00:37:59 +0200575 return -EINVAL;
576
577 if (d_max > d_max_in) {
Rafael J. Wysocki9b5c7a52013-06-27 14:01:02 +0200578 for (d_max = d_max_in; d_max > d_min; d_max--) {
Rafael J. Wysockifa1675b2013-06-16 00:37:59 +0200579 if (adev->power.states[d_max].flags.valid)
580 break;
581 }
582 }
Rafael J. Wysocki9b5c7a52013-06-27 14:01:02 +0200583
584 if (d_min_p)
585 *d_min_p = d_min;
586
Rafael J. Wysockifa1675b2013-06-16 00:37:59 +0200587 return d_max;
Rafael J. Wysockia6ae7592012-11-02 01:40:53 +0100588}
589EXPORT_SYMBOL(acpi_pm_device_sleep_state);
590
Rafael J. Wysockicd7bd022012-11-02 01:40:28 +0100591#ifdef CONFIG_PM_RUNTIME
592/**
Rafael J. Wysockie5cc8ef2012-11-02 01:41:01 +0100593 * acpi_wakeup_device - Wakeup notification handler for ACPI devices.
594 * @handle: ACPI handle of the device the notification is for.
595 * @event: Type of the signaled event.
596 * @context: Device corresponding to @handle.
597 */
598static void acpi_wakeup_device(acpi_handle handle, u32 event, void *context)
599{
600 struct device *dev = context;
601
602 if (event == ACPI_NOTIFY_DEVICE_WAKE && dev) {
603 pm_wakeup_event(dev, 0);
604 pm_runtime_resume(dev);
605 }
606}
607
608/**
Rafael J. Wysockidee83702012-11-02 01:40:36 +0100609 * __acpi_device_run_wake - Enable/disable runtime remote wakeup for device.
610 * @adev: ACPI device to enable/disable the remote wakeup for.
Rafael J. Wysockicd7bd022012-11-02 01:40:28 +0100611 * @enable: Whether to enable or disable the wakeup functionality.
612 *
Rafael J. Wysockidee83702012-11-02 01:40:36 +0100613 * Enable/disable the GPE associated with @adev so that it can generate
614 * wakeup signals for the device in response to external (remote) events and
615 * enable/disable device wakeup power.
616 *
617 * Callers must ensure that @adev is a valid ACPI device node before executing
618 * this function.
619 */
620int __acpi_device_run_wake(struct acpi_device *adev, bool enable)
621{
622 struct acpi_device_wakeup *wakeup = &adev->wakeup;
623
624 if (enable) {
625 acpi_status res;
626 int error;
627
628 error = acpi_enable_wakeup_device_power(adev, ACPI_STATE_S0);
629 if (error)
630 return error;
631
632 res = acpi_enable_gpe(wakeup->gpe_device, wakeup->gpe_number);
633 if (ACPI_FAILURE(res)) {
634 acpi_disable_wakeup_device_power(adev);
635 return -EIO;
636 }
637 } else {
638 acpi_disable_gpe(wakeup->gpe_device, wakeup->gpe_number);
639 acpi_disable_wakeup_device_power(adev);
640 }
641 return 0;
642}
643
644/**
645 * acpi_pm_device_run_wake - Enable/disable remote wakeup for given device.
646 * @dev: Device to enable/disable the platform to wake up.
647 * @enable: Whether to enable or disable the wakeup functionality.
Rafael J. Wysockicd7bd022012-11-02 01:40:28 +0100648 */
649int acpi_pm_device_run_wake(struct device *phys_dev, bool enable)
650{
Rafael J. Wysockidee83702012-11-02 01:40:36 +0100651 struct acpi_device *adev;
Rafael J. Wysockicd7bd022012-11-02 01:40:28 +0100652 acpi_handle handle;
653
654 if (!device_run_wake(phys_dev))
655 return -EINVAL;
656
657 handle = DEVICE_ACPI_HANDLE(phys_dev);
Yasuaki Ishimatsudde3bb42013-01-31 03:22:14 +0000658 if (!handle || acpi_bus_get_device(handle, &adev)) {
Rafael J. Wysockidee83702012-11-02 01:40:36 +0100659 dev_dbg(phys_dev, "ACPI handle without context in %s!\n",
Rafael J. Wysockicd7bd022012-11-02 01:40:28 +0100660 __func__);
661 return -ENODEV;
662 }
663
Rafael J. Wysockidee83702012-11-02 01:40:36 +0100664 return __acpi_device_run_wake(adev, enable);
Rafael J. Wysockicd7bd022012-11-02 01:40:28 +0100665}
666EXPORT_SYMBOL(acpi_pm_device_run_wake);
Rafael J. Wysockie5cc8ef2012-11-02 01:41:01 +0100667#else
668static inline void acpi_wakeup_device(acpi_handle handle, u32 event,
669 void *context) {}
Rafael J. Wysockicd7bd022012-11-02 01:40:28 +0100670#endif /* CONFIG_PM_RUNTIME */
Rafael J. Wysockidee83702012-11-02 01:40:36 +0100671
Mika Westerberg4d564102013-01-14 20:13:37 +0000672#ifdef CONFIG_PM_SLEEP
Rafael J. Wysockidee83702012-11-02 01:40:36 +0100673/**
674 * __acpi_device_sleep_wake - Enable or disable device to wake up the system.
675 * @dev: Device to enable/desible to wake up the system.
676 * @target_state: System state the device is supposed to wake up from.
677 * @enable: Whether to enable or disable @dev to wake up the system.
678 */
679int __acpi_device_sleep_wake(struct acpi_device *adev, u32 target_state,
680 bool enable)
681{
682 return enable ?
683 acpi_enable_wakeup_device_power(adev, target_state) :
684 acpi_disable_wakeup_device_power(adev);
685}
Rafael J. Wysockia6ae7592012-11-02 01:40:53 +0100686
687/**
688 * acpi_pm_device_sleep_wake - Enable or disable device to wake up the system.
689 * @dev: Device to enable/desible to wake up the system from sleep states.
690 * @enable: Whether to enable or disable @dev to wake up the system.
691 */
692int acpi_pm_device_sleep_wake(struct device *dev, bool enable)
693{
694 acpi_handle handle;
695 struct acpi_device *adev;
696 int error;
697
698 if (!device_can_wakeup(dev))
699 return -EINVAL;
700
701 handle = DEVICE_ACPI_HANDLE(dev);
Yasuaki Ishimatsudde3bb42013-01-31 03:22:14 +0000702 if (!handle || acpi_bus_get_device(handle, &adev)) {
Rafael J. Wysockia6ae7592012-11-02 01:40:53 +0100703 dev_dbg(dev, "ACPI handle without context in %s!\n", __func__);
704 return -ENODEV;
705 }
706
707 error = __acpi_device_sleep_wake(adev, acpi_target_system_state(),
708 enable);
709 if (!error)
710 dev_info(dev, "System wakeup %s by ACPI\n",
711 enable ? "enabled" : "disabled");
712
713 return error;
714}
Rafael J. Wysockidee83702012-11-02 01:40:36 +0100715#endif /* CONFIG_PM_SLEEP */
Rafael J. Wysockie5cc8ef2012-11-02 01:41:01 +0100716
717/**
718 * acpi_dev_pm_get_node - Get ACPI device node for the given physical device.
719 * @dev: Device to get the ACPI node for.
720 */
Rafael J. Wysockid2e5f0c2012-12-23 00:02:44 +0100721struct acpi_device *acpi_dev_pm_get_node(struct device *dev)
Rafael J. Wysockie5cc8ef2012-11-02 01:41:01 +0100722{
723 acpi_handle handle = DEVICE_ACPI_HANDLE(dev);
724 struct acpi_device *adev;
725
Rafael J. Wysocki5cc36c72012-12-16 23:28:53 +0100726 return handle && !acpi_bus_get_device(handle, &adev) ? adev : NULL;
Rafael J. Wysockie5cc8ef2012-11-02 01:41:01 +0100727}
728
729/**
730 * acpi_dev_pm_low_power - Put ACPI device into a low-power state.
731 * @dev: Device to put into a low-power state.
732 * @adev: ACPI device node corresponding to @dev.
733 * @system_state: System state to choose the device state for.
734 */
735static int acpi_dev_pm_low_power(struct device *dev, struct acpi_device *adev,
736 u32 system_state)
737{
Rafael J. Wysockifa1675b2013-06-16 00:37:59 +0200738 int ret, state;
Rafael J. Wysockie5cc8ef2012-11-02 01:41:01 +0100739
740 if (!acpi_device_power_manageable(adev))
741 return 0;
742
Rafael J. Wysockifa1675b2013-06-16 00:37:59 +0200743 ret = acpi_dev_pm_get_state(dev, adev, system_state, NULL, &state);
744 return ret ? ret : acpi_device_set_power(adev, state);
Rafael J. Wysockie5cc8ef2012-11-02 01:41:01 +0100745}
746
747/**
748 * acpi_dev_pm_full_power - Put ACPI device into the full-power state.
749 * @adev: ACPI device node to put into the full-power state.
750 */
751static int acpi_dev_pm_full_power(struct acpi_device *adev)
752{
753 return acpi_device_power_manageable(adev) ?
754 acpi_device_set_power(adev, ACPI_STATE_D0) : 0;
755}
756
757#ifdef CONFIG_PM_RUNTIME
758/**
759 * acpi_dev_runtime_suspend - Put device into a low-power state using ACPI.
760 * @dev: Device to put into a low-power state.
761 *
762 * Put the given device into a runtime low-power state using the standard ACPI
763 * mechanism. Set up remote wakeup if desired, choose the state to put the
764 * device into (this checks if remote wakeup is expected to work too), and set
765 * the power state of the device.
766 */
767int acpi_dev_runtime_suspend(struct device *dev)
768{
769 struct acpi_device *adev = acpi_dev_pm_get_node(dev);
770 bool remote_wakeup;
771 int error;
772
773 if (!adev)
774 return 0;
775
776 remote_wakeup = dev_pm_qos_flags(dev, PM_QOS_FLAG_REMOTE_WAKEUP) >
777 PM_QOS_FLAGS_NONE;
778 error = __acpi_device_run_wake(adev, remote_wakeup);
779 if (remote_wakeup && error)
780 return -EAGAIN;
781
782 error = acpi_dev_pm_low_power(dev, adev, ACPI_STATE_S0);
783 if (error)
784 __acpi_device_run_wake(adev, false);
785
786 return error;
787}
788EXPORT_SYMBOL_GPL(acpi_dev_runtime_suspend);
789
790/**
791 * acpi_dev_runtime_resume - Put device into the full-power state using ACPI.
792 * @dev: Device to put into the full-power state.
793 *
794 * Put the given device into the full-power state using the standard ACPI
795 * mechanism at run time. Set the power state of the device to ACPI D0 and
796 * disable remote wakeup.
797 */
798int acpi_dev_runtime_resume(struct device *dev)
799{
800 struct acpi_device *adev = acpi_dev_pm_get_node(dev);
801 int error;
802
803 if (!adev)
804 return 0;
805
806 error = acpi_dev_pm_full_power(adev);
807 __acpi_device_run_wake(adev, false);
808 return error;
809}
810EXPORT_SYMBOL_GPL(acpi_dev_runtime_resume);
811
812/**
813 * acpi_subsys_runtime_suspend - Suspend device using ACPI.
814 * @dev: Device to suspend.
815 *
816 * Carry out the generic runtime suspend procedure for @dev and use ACPI to put
817 * it into a runtime low-power state.
818 */
819int acpi_subsys_runtime_suspend(struct device *dev)
820{
821 int ret = pm_generic_runtime_suspend(dev);
822 return ret ? ret : acpi_dev_runtime_suspend(dev);
823}
824EXPORT_SYMBOL_GPL(acpi_subsys_runtime_suspend);
825
826/**
827 * acpi_subsys_runtime_resume - Resume device using ACPI.
828 * @dev: Device to Resume.
829 *
830 * Use ACPI to put the given device into the full-power state and carry out the
831 * generic runtime resume procedure for it.
832 */
833int acpi_subsys_runtime_resume(struct device *dev)
834{
835 int ret = acpi_dev_runtime_resume(dev);
836 return ret ? ret : pm_generic_runtime_resume(dev);
837}
838EXPORT_SYMBOL_GPL(acpi_subsys_runtime_resume);
839#endif /* CONFIG_PM_RUNTIME */
840
841#ifdef CONFIG_PM_SLEEP
842/**
843 * acpi_dev_suspend_late - Put device into a low-power state using ACPI.
844 * @dev: Device to put into a low-power state.
845 *
846 * Put the given device into a low-power state during system transition to a
847 * sleep state using the standard ACPI mechanism. Set up system wakeup if
848 * desired, choose the state to put the device into (this checks if system
849 * wakeup is expected to work too), and set the power state of the device.
850 */
851int acpi_dev_suspend_late(struct device *dev)
852{
853 struct acpi_device *adev = acpi_dev_pm_get_node(dev);
854 u32 target_state;
855 bool wakeup;
856 int error;
857
858 if (!adev)
859 return 0;
860
861 target_state = acpi_target_system_state();
862 wakeup = device_may_wakeup(dev);
863 error = __acpi_device_sleep_wake(adev, target_state, wakeup);
864 if (wakeup && error)
865 return error;
866
867 error = acpi_dev_pm_low_power(dev, adev, target_state);
868 if (error)
869 __acpi_device_sleep_wake(adev, ACPI_STATE_UNKNOWN, false);
870
871 return error;
872}
873EXPORT_SYMBOL_GPL(acpi_dev_suspend_late);
874
875/**
876 * acpi_dev_resume_early - Put device into the full-power state using ACPI.
877 * @dev: Device to put into the full-power state.
878 *
879 * Put the given device into the full-power state using the standard ACPI
880 * mechanism during system transition to the working state. Set the power
881 * state of the device to ACPI D0 and disable remote wakeup.
882 */
883int acpi_dev_resume_early(struct device *dev)
884{
885 struct acpi_device *adev = acpi_dev_pm_get_node(dev);
886 int error;
887
888 if (!adev)
889 return 0;
890
891 error = acpi_dev_pm_full_power(adev);
892 __acpi_device_sleep_wake(adev, ACPI_STATE_UNKNOWN, false);
893 return error;
894}
895EXPORT_SYMBOL_GPL(acpi_dev_resume_early);
896
897/**
898 * acpi_subsys_prepare - Prepare device for system transition to a sleep state.
899 * @dev: Device to prepare.
900 */
901int acpi_subsys_prepare(struct device *dev)
902{
903 /*
904 * Follow PCI and resume devices suspended at run time before running
905 * their system suspend callbacks.
906 */
907 pm_runtime_resume(dev);
908 return pm_generic_prepare(dev);
909}
910EXPORT_SYMBOL_GPL(acpi_subsys_prepare);
911
912/**
913 * acpi_subsys_suspend_late - Suspend device using ACPI.
914 * @dev: Device to suspend.
915 *
916 * Carry out the generic late suspend procedure for @dev and use ACPI to put
917 * it into a low-power state during system transition into a sleep state.
918 */
919int acpi_subsys_suspend_late(struct device *dev)
920{
921 int ret = pm_generic_suspend_late(dev);
922 return ret ? ret : acpi_dev_suspend_late(dev);
923}
924EXPORT_SYMBOL_GPL(acpi_subsys_suspend_late);
925
926/**
927 * acpi_subsys_resume_early - Resume device using ACPI.
928 * @dev: Device to Resume.
929 *
930 * Use ACPI to put the given device into the full-power state and carry out the
931 * generic early resume procedure for it during system transition into the
932 * working state.
933 */
934int acpi_subsys_resume_early(struct device *dev)
935{
936 int ret = acpi_dev_resume_early(dev);
937 return ret ? ret : pm_generic_resume_early(dev);
938}
939EXPORT_SYMBOL_GPL(acpi_subsys_resume_early);
940#endif /* CONFIG_PM_SLEEP */
941
942static struct dev_pm_domain acpi_general_pm_domain = {
943 .ops = {
944#ifdef CONFIG_PM_RUNTIME
945 .runtime_suspend = acpi_subsys_runtime_suspend,
946 .runtime_resume = acpi_subsys_runtime_resume,
Rafael J. Wysockie5cc8ef2012-11-02 01:41:01 +0100947#endif
948#ifdef CONFIG_PM_SLEEP
949 .prepare = acpi_subsys_prepare,
950 .suspend_late = acpi_subsys_suspend_late,
951 .resume_early = acpi_subsys_resume_early,
952 .poweroff_late = acpi_subsys_suspend_late,
953 .restore_early = acpi_subsys_resume_early,
954#endif
955 },
956};
957
958/**
959 * acpi_dev_pm_attach - Prepare device for ACPI power management.
960 * @dev: Device to prepare.
Rafael J. Wysockib88ce2a2012-11-26 10:03:06 +0100961 * @power_on: Whether or not to power on the device.
Rafael J. Wysockie5cc8ef2012-11-02 01:41:01 +0100962 *
963 * If @dev has a valid ACPI handle that has a valid struct acpi_device object
964 * attached to it, install a wakeup notification handler for the device and
Rafael J. Wysockib88ce2a2012-11-26 10:03:06 +0100965 * add it to the general ACPI PM domain. If @power_on is set, the device will
966 * be put into the ACPI D0 state before the function returns.
Rafael J. Wysockie5cc8ef2012-11-02 01:41:01 +0100967 *
968 * This assumes that the @dev's bus type uses generic power management callbacks
969 * (or doesn't use any power management callbacks at all).
970 *
971 * Callers must ensure proper synchronization of this function with power
972 * management callbacks.
973 */
Rafael J. Wysockib88ce2a2012-11-26 10:03:06 +0100974int acpi_dev_pm_attach(struct device *dev, bool power_on)
Rafael J. Wysockie5cc8ef2012-11-02 01:41:01 +0100975{
976 struct acpi_device *adev = acpi_dev_pm_get_node(dev);
977
978 if (!adev)
979 return -ENODEV;
980
981 if (dev->pm_domain)
982 return -EEXIST;
983
984 acpi_add_pm_notifier(adev, acpi_wakeup_device, dev);
985 dev->pm_domain = &acpi_general_pm_domain;
Rafael J. Wysockib88ce2a2012-11-26 10:03:06 +0100986 if (power_on) {
987 acpi_dev_pm_full_power(adev);
988 __acpi_device_run_wake(adev, false);
989 }
Rafael J. Wysockie5cc8ef2012-11-02 01:41:01 +0100990 return 0;
991}
992EXPORT_SYMBOL_GPL(acpi_dev_pm_attach);
993
994/**
995 * acpi_dev_pm_detach - Remove ACPI power management from the device.
996 * @dev: Device to take care of.
Rafael J. Wysockib88ce2a2012-11-26 10:03:06 +0100997 * @power_off: Whether or not to try to remove power from the device.
Rafael J. Wysockie5cc8ef2012-11-02 01:41:01 +0100998 *
999 * Remove the device from the general ACPI PM domain and remove its wakeup
Rafael J. Wysockib88ce2a2012-11-26 10:03:06 +01001000 * notifier. If @power_off is set, additionally remove power from the device if
1001 * possible.
Rafael J. Wysockie5cc8ef2012-11-02 01:41:01 +01001002 *
1003 * Callers must ensure proper synchronization of this function with power
1004 * management callbacks.
1005 */
Rafael J. Wysockib88ce2a2012-11-26 10:03:06 +01001006void acpi_dev_pm_detach(struct device *dev, bool power_off)
Rafael J. Wysockie5cc8ef2012-11-02 01:41:01 +01001007{
1008 struct acpi_device *adev = acpi_dev_pm_get_node(dev);
1009
1010 if (adev && dev->pm_domain == &acpi_general_pm_domain) {
1011 dev->pm_domain = NULL;
1012 acpi_remove_pm_notifier(adev, acpi_wakeup_device);
Rafael J. Wysockib88ce2a2012-11-26 10:03:06 +01001013 if (power_off) {
1014 /*
1015 * If the device's PM QoS resume latency limit or flags
1016 * have been exposed to user space, they have to be
1017 * hidden at this point, so that they don't affect the
1018 * choice of the low-power state to put the device into.
1019 */
1020 dev_pm_qos_hide_latency_limit(dev);
1021 dev_pm_qos_hide_flags(dev);
1022 __acpi_device_run_wake(adev, false);
1023 acpi_dev_pm_low_power(dev, adev, ACPI_STATE_S0);
1024 }
Rafael J. Wysockie5cc8ef2012-11-02 01:41:01 +01001025 }
1026}
1027EXPORT_SYMBOL_GPL(acpi_dev_pm_detach);
Rafael J. Wysockiec4602a2013-05-16 22:29:28 +02001028#endif /* CONFIG_PM */