Linux 4.1.16
[linux/fpc-iii.git] / drivers / acpi / device_pm.c
blob8217e0bda60f6e1aa96abc158810b4797fe9d47e
1 /*
2 * drivers/acpi/device_pm.c - ACPI device power management routines.
4 * Copyright (C) 2012, Intel Corp.
5 * Author: Rafael J. Wysocki <rafael.j.wysocki@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 version 2 as published
11 * by the Free Software Foundation.
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.
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.
22 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
25 #include <linux/acpi.h>
26 #include <linux/export.h>
27 #include <linux/mutex.h>
28 #include <linux/pm_qos.h>
29 #include <linux/pm_runtime.h>
31 #include "internal.h"
33 #define _COMPONENT ACPI_POWER_COMPONENT
34 ACPI_MODULE_NAME("device_pm");
36 /**
37 * acpi_power_state_string - String representation of ACPI device power state.
38 * @state: ACPI device power state to return the string representation of.
40 const char *acpi_power_state_string(int state)
42 switch (state) {
43 case ACPI_STATE_D0:
44 return "D0";
45 case ACPI_STATE_D1:
46 return "D1";
47 case ACPI_STATE_D2:
48 return "D2";
49 case ACPI_STATE_D3_HOT:
50 return "D3hot";
51 case ACPI_STATE_D3_COLD:
52 return "D3cold";
53 default:
54 return "(unknown)";
58 /**
59 * acpi_device_get_power - Get power state of an ACPI device.
60 * @device: Device to get the power state of.
61 * @state: Place to store the power state of the device.
63 * This function does not update the device's power.state field, but it may
64 * update its parent's power.state field (when the parent's power state is
65 * unknown and the device's power state turns out to be D0).
67 int acpi_device_get_power(struct acpi_device *device, int *state)
69 int result = ACPI_STATE_UNKNOWN;
71 if (!device || !state)
72 return -EINVAL;
74 if (!device->flags.power_manageable) {
75 /* TBD: Non-recursive algorithm for walking up hierarchy. */
76 *state = device->parent ?
77 device->parent->power.state : ACPI_STATE_D0;
78 goto out;
82 * Get the device's power state from power resources settings and _PSC,
83 * if available.
85 if (device->power.flags.power_resources) {
86 int error = acpi_power_get_inferred_state(device, &result);
87 if (error)
88 return error;
90 if (device->power.flags.explicit_get) {
91 acpi_handle handle = device->handle;
92 unsigned long long psc;
93 acpi_status status;
95 status = acpi_evaluate_integer(handle, "_PSC", NULL, &psc);
96 if (ACPI_FAILURE(status))
97 return -ENODEV;
100 * The power resources settings may indicate a power state
101 * shallower than the actual power state of the device.
103 * Moreover, on systems predating ACPI 4.0, if the device
104 * doesn't depend on any power resources and _PSC returns 3,
105 * that means "power off". We need to maintain compatibility
106 * with those systems.
108 if (psc > result && psc < ACPI_STATE_D3_COLD)
109 result = psc;
110 else if (result == ACPI_STATE_UNKNOWN)
111 result = psc > ACPI_STATE_D2 ? ACPI_STATE_D3_COLD : psc;
115 * If we were unsure about the device parent's power state up to this
116 * point, the fact that the device is in D0 implies that the parent has
117 * to be in D0 too, except if ignore_parent is set.
119 if (!device->power.flags.ignore_parent && device->parent
120 && device->parent->power.state == ACPI_STATE_UNKNOWN
121 && result == ACPI_STATE_D0)
122 device->parent->power.state = ACPI_STATE_D0;
124 *state = result;
126 out:
127 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device [%s] power state is %s\n",
128 device->pnp.bus_id, acpi_power_state_string(*state)));
130 return 0;
133 static int acpi_dev_pm_explicit_set(struct acpi_device *adev, int state)
135 if (adev->power.states[state].flags.explicit_set) {
136 char method[5] = { '_', 'P', 'S', '0' + state, '\0' };
137 acpi_status status;
139 status = acpi_evaluate_object(adev->handle, method, NULL, NULL);
140 if (ACPI_FAILURE(status))
141 return -ENODEV;
143 return 0;
147 * acpi_device_set_power - Set power state of an ACPI device.
148 * @device: Device to set the power state of.
149 * @state: New power state to set.
151 * Callers must ensure that the device is power manageable before using this
152 * function.
154 int acpi_device_set_power(struct acpi_device *device, int state)
156 int result = 0;
157 bool cut_power = false;
159 if (!device || !device->flags.power_manageable
160 || (state < ACPI_STATE_D0) || (state > ACPI_STATE_D3_COLD))
161 return -EINVAL;
163 /* Make sure this is a valid target state */
165 if (state == device->power.state) {
166 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device [%s] already in %s\n",
167 device->pnp.bus_id,
168 acpi_power_state_string(state)));
169 return 0;
172 if (!device->power.states[state].flags.valid) {
173 dev_warn(&device->dev, "Power state %s not supported\n",
174 acpi_power_state_string(state));
175 return -ENODEV;
177 if (!device->power.flags.ignore_parent &&
178 device->parent && (state < device->parent->power.state)) {
179 dev_warn(&device->dev,
180 "Cannot transition to power state %s for parent in %s\n",
181 acpi_power_state_string(state),
182 acpi_power_state_string(device->parent->power.state));
183 return -ENODEV;
186 /* For D3cold we should first transition into D3hot. */
187 if (state == ACPI_STATE_D3_COLD
188 && device->power.states[ACPI_STATE_D3_COLD].flags.os_accessible) {
189 state = ACPI_STATE_D3_HOT;
190 cut_power = true;
193 if (state < device->power.state && state != ACPI_STATE_D0
194 && device->power.state >= ACPI_STATE_D3_HOT) {
195 dev_warn(&device->dev,
196 "Cannot transition to non-D0 state from D3\n");
197 return -ENODEV;
201 * Transition Power
202 * ----------------
203 * In accordance with the ACPI specification first apply power (via
204 * power resources) and then evaluate _PSx.
206 if (device->power.flags.power_resources) {
207 result = acpi_power_transition(device, state);
208 if (result)
209 goto end;
211 result = acpi_dev_pm_explicit_set(device, state);
212 if (result)
213 goto end;
215 if (cut_power) {
216 device->power.state = state;
217 state = ACPI_STATE_D3_COLD;
218 result = acpi_power_transition(device, state);
221 end:
222 if (result) {
223 dev_warn(&device->dev, "Failed to change power state to %s\n",
224 acpi_power_state_string(state));
225 } else {
226 device->power.state = state;
227 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
228 "Device [%s] transitioned to %s\n",
229 device->pnp.bus_id,
230 acpi_power_state_string(state)));
233 return result;
235 EXPORT_SYMBOL(acpi_device_set_power);
237 int acpi_bus_set_power(acpi_handle handle, int state)
239 struct acpi_device *device;
240 int result;
242 result = acpi_bus_get_device(handle, &device);
243 if (result)
244 return result;
246 return acpi_device_set_power(device, state);
248 EXPORT_SYMBOL(acpi_bus_set_power);
250 int acpi_bus_init_power(struct acpi_device *device)
252 int state;
253 int result;
255 if (!device)
256 return -EINVAL;
258 device->power.state = ACPI_STATE_UNKNOWN;
259 if (!acpi_device_is_present(device))
260 return -ENXIO;
262 result = acpi_device_get_power(device, &state);
263 if (result)
264 return result;
266 if (state < ACPI_STATE_D3_COLD && device->power.flags.power_resources) {
267 result = acpi_power_on_resources(device, state);
268 if (result)
269 return result;
271 result = acpi_dev_pm_explicit_set(device, state);
272 if (result)
273 return result;
274 } else if (state == ACPI_STATE_UNKNOWN) {
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.]
281 state = ACPI_STATE_D0;
283 device->power.state = state;
284 return 0;
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.
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.
295 int acpi_device_fix_up_power(struct acpi_device *device)
297 int ret = 0;
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);
304 return ret;
307 int acpi_device_update_power(struct acpi_device *device, int *state_p)
309 int state;
310 int result;
312 if (device->power.state == ACPI_STATE_UNKNOWN) {
313 result = acpi_bus_init_power(device);
314 if (!result && state_p)
315 *state_p = device->power.state;
317 return result;
320 result = acpi_device_get_power(device, &state);
321 if (result)
322 return result;
324 if (state == ACPI_STATE_UNKNOWN) {
325 state = ACPI_STATE_D0;
326 result = acpi_device_set_power(device, state);
327 if (result)
328 return result;
329 } else {
330 if (device->power.flags.power_resources) {
332 * We don't need to really switch the state, bu we need
333 * to update the power resources' reference counters.
335 result = acpi_power_transition(device, state);
336 if (result)
337 return result;
339 device->power.state = state;
341 if (state_p)
342 *state_p = state;
344 return 0;
346 EXPORT_SYMBOL_GPL(acpi_device_update_power);
348 int acpi_bus_update_power(acpi_handle handle, int *state_p)
350 struct acpi_device *device;
351 int result;
353 result = acpi_bus_get_device(handle, &device);
354 return result ? result : acpi_device_update_power(device, state_p);
356 EXPORT_SYMBOL_GPL(acpi_bus_update_power);
358 bool acpi_bus_power_manageable(acpi_handle handle)
360 struct acpi_device *device;
361 int result;
363 result = acpi_bus_get_device(handle, &device);
364 return result ? false : device->flags.power_manageable;
366 EXPORT_SYMBOL(acpi_bus_power_manageable);
368 #ifdef CONFIG_PM
369 static DEFINE_MUTEX(acpi_pm_notifier_lock);
371 static void acpi_pm_notify_handler(acpi_handle handle, u32 val, void *not_used)
373 struct acpi_device *adev;
375 if (val != ACPI_NOTIFY_DEVICE_WAKE)
376 return;
378 adev = acpi_bus_get_acpi_device(handle);
379 if (!adev)
380 return;
382 mutex_lock(&acpi_pm_notifier_lock);
384 if (adev->wakeup.flags.notifier_present) {
385 __pm_wakeup_event(adev->wakeup.ws, 0);
386 if (adev->wakeup.context.work.func)
387 queue_pm_work(&adev->wakeup.context.work);
390 mutex_unlock(&acpi_pm_notifier_lock);
392 acpi_bus_put_acpi_device(adev);
396 * acpi_add_pm_notifier - Register PM notify handler for given ACPI device.
397 * @adev: ACPI device to add the notify handler for.
398 * @dev: Device to generate a wakeup event for while handling the notification.
399 * @work_func: Work function to execute when handling the notification.
401 * NOTE: @adev need not be a run-wake or wakeup device to be a valid source of
402 * PM wakeup events. For example, wakeup events may be generated for bridges
403 * if one of the devices below the bridge is signaling wakeup, even if the
404 * bridge itself doesn't have a wakeup GPE associated with it.
406 acpi_status acpi_add_pm_notifier(struct acpi_device *adev, struct device *dev,
407 void (*work_func)(struct work_struct *work))
409 acpi_status status = AE_ALREADY_EXISTS;
411 if (!dev && !work_func)
412 return AE_BAD_PARAMETER;
414 mutex_lock(&acpi_pm_notifier_lock);
416 if (adev->wakeup.flags.notifier_present)
417 goto out;
419 adev->wakeup.ws = wakeup_source_register(dev_name(&adev->dev));
420 adev->wakeup.context.dev = dev;
421 if (work_func)
422 INIT_WORK(&adev->wakeup.context.work, work_func);
424 status = acpi_install_notify_handler(adev->handle, ACPI_SYSTEM_NOTIFY,
425 acpi_pm_notify_handler, NULL);
426 if (ACPI_FAILURE(status))
427 goto out;
429 adev->wakeup.flags.notifier_present = true;
431 out:
432 mutex_unlock(&acpi_pm_notifier_lock);
433 return status;
437 * acpi_remove_pm_notifier - Unregister PM notifier from given ACPI device.
438 * @adev: ACPI device to remove the notifier from.
440 acpi_status acpi_remove_pm_notifier(struct acpi_device *adev)
442 acpi_status status = AE_BAD_PARAMETER;
444 mutex_lock(&acpi_pm_notifier_lock);
446 if (!adev->wakeup.flags.notifier_present)
447 goto out;
449 status = acpi_remove_notify_handler(adev->handle,
450 ACPI_SYSTEM_NOTIFY,
451 acpi_pm_notify_handler);
452 if (ACPI_FAILURE(status))
453 goto out;
455 if (adev->wakeup.context.work.func) {
456 cancel_work_sync(&adev->wakeup.context.work);
457 adev->wakeup.context.work.func = NULL;
459 adev->wakeup.context.dev = NULL;
460 wakeup_source_unregister(adev->wakeup.ws);
462 adev->wakeup.flags.notifier_present = false;
464 out:
465 mutex_unlock(&acpi_pm_notifier_lock);
466 return status;
469 bool acpi_bus_can_wakeup(acpi_handle handle)
471 struct acpi_device *device;
472 int result;
474 result = acpi_bus_get_device(handle, &device);
475 return result ? false : device->wakeup.flags.valid;
477 EXPORT_SYMBOL(acpi_bus_can_wakeup);
480 * acpi_dev_pm_get_state - Get preferred power state of ACPI device.
481 * @dev: Device whose preferred target power state to return.
482 * @adev: ACPI device node corresponding to @dev.
483 * @target_state: System state to match the resultant device state.
484 * @d_min_p: Location to store the highest power state available to the device.
485 * @d_max_p: Location to store the lowest power state available to the device.
487 * Find the lowest power (highest number) and highest power (lowest number) ACPI
488 * device power states that the device can be in while the system is in the
489 * state represented by @target_state. Store the integer numbers representing
490 * those stats in the memory locations pointed to by @d_max_p and @d_min_p,
491 * respectively.
493 * Callers must ensure that @dev and @adev are valid pointers and that @adev
494 * actually corresponds to @dev before using this function.
496 * Returns 0 on success or -ENODATA when one of the ACPI methods fails or
497 * returns a value that doesn't make sense. The memory locations pointed to by
498 * @d_max_p and @d_min_p are only modified on success.
500 static int acpi_dev_pm_get_state(struct device *dev, struct acpi_device *adev,
501 u32 target_state, int *d_min_p, int *d_max_p)
503 char method[] = { '_', 'S', '0' + target_state, 'D', '\0' };
504 acpi_handle handle = adev->handle;
505 unsigned long long ret;
506 int d_min, d_max;
507 bool wakeup = false;
508 acpi_status status;
511 * If the system state is S0, the lowest power state the device can be
512 * in is D3cold, unless the device has _S0W and is supposed to signal
513 * wakeup, in which case the return value of _S0W has to be used as the
514 * lowest power state available to the device.
516 d_min = ACPI_STATE_D0;
517 d_max = ACPI_STATE_D3_COLD;
520 * If present, _SxD methods return the minimum D-state (highest power
521 * state) we can use for the corresponding S-states. Otherwise, the
522 * minimum D-state is D0 (ACPI 3.x).
524 if (target_state > ACPI_STATE_S0) {
526 * We rely on acpi_evaluate_integer() not clobbering the integer
527 * provided if AE_NOT_FOUND is returned.
529 ret = d_min;
530 status = acpi_evaluate_integer(handle, method, NULL, &ret);
531 if ((ACPI_FAILURE(status) && status != AE_NOT_FOUND)
532 || ret > ACPI_STATE_D3_COLD)
533 return -ENODATA;
536 * We need to handle legacy systems where D3hot and D3cold are
537 * the same and 3 is returned in both cases, so fall back to
538 * D3cold if D3hot is not a valid state.
540 if (!adev->power.states[ret].flags.valid) {
541 if (ret == ACPI_STATE_D3_HOT)
542 ret = ACPI_STATE_D3_COLD;
543 else
544 return -ENODATA;
546 d_min = ret;
547 wakeup = device_may_wakeup(dev) && adev->wakeup.flags.valid
548 && adev->wakeup.sleep_state >= target_state;
549 } else if (dev_pm_qos_flags(dev, PM_QOS_FLAG_REMOTE_WAKEUP) !=
550 PM_QOS_FLAGS_NONE) {
551 wakeup = adev->wakeup.flags.valid;
555 * If _PRW says we can wake up the system from the target sleep state,
556 * the D-state returned by _SxD is sufficient for that (we assume a
557 * wakeup-aware driver if wake is set). Still, if _SxW exists
558 * (ACPI 3.x), it should return the maximum (lowest power) D-state that
559 * can wake the system. _S0W may be valid, too.
561 if (wakeup) {
562 method[3] = 'W';
563 status = acpi_evaluate_integer(handle, method, NULL, &ret);
564 if (status == AE_NOT_FOUND) {
565 if (target_state > ACPI_STATE_S0)
566 d_max = d_min;
567 } else if (ACPI_SUCCESS(status) && ret <= ACPI_STATE_D3_COLD) {
568 /* Fall back to D3cold if ret is not a valid state. */
569 if (!adev->power.states[ret].flags.valid)
570 ret = ACPI_STATE_D3_COLD;
572 d_max = ret > d_min ? ret : d_min;
573 } else {
574 return -ENODATA;
578 if (d_min_p)
579 *d_min_p = d_min;
581 if (d_max_p)
582 *d_max_p = d_max;
584 return 0;
588 * acpi_pm_device_sleep_state - Get preferred power state of ACPI device.
589 * @dev: Device whose preferred target power state to return.
590 * @d_min_p: Location to store the upper limit of the allowed states range.
591 * @d_max_in: Deepest low-power state to take into consideration.
592 * Return value: Preferred power state of the device on success, -ENODEV
593 * if there's no 'struct acpi_device' for @dev, -EINVAL if @d_max_in is
594 * incorrect, or -ENODATA on ACPI method failure.
596 * The caller must ensure that @dev is valid before using this function.
598 int acpi_pm_device_sleep_state(struct device *dev, int *d_min_p, int d_max_in)
600 struct acpi_device *adev;
601 int ret, d_min, d_max;
603 if (d_max_in < ACPI_STATE_D0 || d_max_in > ACPI_STATE_D3_COLD)
604 return -EINVAL;
606 if (d_max_in > ACPI_STATE_D3_HOT) {
607 enum pm_qos_flags_status stat;
609 stat = dev_pm_qos_flags(dev, PM_QOS_FLAG_NO_POWER_OFF);
610 if (stat == PM_QOS_FLAGS_ALL)
611 d_max_in = ACPI_STATE_D3_HOT;
614 adev = ACPI_COMPANION(dev);
615 if (!adev) {
616 dev_dbg(dev, "ACPI companion missing in %s!\n", __func__);
617 return -ENODEV;
620 ret = acpi_dev_pm_get_state(dev, adev, acpi_target_system_state(),
621 &d_min, &d_max);
622 if (ret)
623 return ret;
625 if (d_max_in < d_min)
626 return -EINVAL;
628 if (d_max > d_max_in) {
629 for (d_max = d_max_in; d_max > d_min; d_max--) {
630 if (adev->power.states[d_max].flags.valid)
631 break;
635 if (d_min_p)
636 *d_min_p = d_min;
638 return d_max;
640 EXPORT_SYMBOL(acpi_pm_device_sleep_state);
643 * acpi_pm_notify_work_func - ACPI devices wakeup notification work function.
644 * @work: Work item to handle.
646 static void acpi_pm_notify_work_func(struct work_struct *work)
648 struct device *dev;
650 dev = container_of(work, struct acpi_device_wakeup_context, work)->dev;
651 if (dev) {
652 pm_wakeup_event(dev, 0);
653 pm_runtime_resume(dev);
658 * acpi_device_wakeup - Enable/disable wakeup functionality for device.
659 * @adev: ACPI device to enable/disable wakeup functionality for.
660 * @target_state: State the system is transitioning into.
661 * @enable: Whether to enable or disable the wakeup functionality.
663 * Enable/disable the GPE associated with @adev so that it can generate
664 * wakeup signals for the device in response to external (remote) events and
665 * enable/disable device wakeup power.
667 * Callers must ensure that @adev is a valid ACPI device node before executing
668 * this function.
670 static int acpi_device_wakeup(struct acpi_device *adev, u32 target_state,
671 bool enable)
673 struct acpi_device_wakeup *wakeup = &adev->wakeup;
675 if (enable) {
676 acpi_status res;
677 int error;
679 error = acpi_enable_wakeup_device_power(adev, target_state);
680 if (error)
681 return error;
683 if (adev->wakeup.flags.enabled)
684 return 0;
686 res = acpi_enable_gpe(wakeup->gpe_device, wakeup->gpe_number);
687 if (ACPI_SUCCESS(res)) {
688 adev->wakeup.flags.enabled = 1;
689 } else {
690 acpi_disable_wakeup_device_power(adev);
691 return -EIO;
693 } else {
694 if (adev->wakeup.flags.enabled) {
695 acpi_disable_gpe(wakeup->gpe_device, wakeup->gpe_number);
696 adev->wakeup.flags.enabled = 0;
698 acpi_disable_wakeup_device_power(adev);
700 return 0;
704 * acpi_pm_device_run_wake - Enable/disable remote wakeup for given device.
705 * @dev: Device to enable/disable the platform to wake up.
706 * @enable: Whether to enable or disable the wakeup functionality.
708 int acpi_pm_device_run_wake(struct device *phys_dev, bool enable)
710 struct acpi_device *adev;
712 if (!device_run_wake(phys_dev))
713 return -EINVAL;
715 adev = ACPI_COMPANION(phys_dev);
716 if (!adev) {
717 dev_dbg(phys_dev, "ACPI companion missing in %s!\n", __func__);
718 return -ENODEV;
721 return acpi_device_wakeup(adev, ACPI_STATE_S0, enable);
723 EXPORT_SYMBOL(acpi_pm_device_run_wake);
725 #ifdef CONFIG_PM_SLEEP
727 * acpi_pm_device_sleep_wake - Enable or disable device to wake up the system.
728 * @dev: Device to enable/desible to wake up the system from sleep states.
729 * @enable: Whether to enable or disable @dev to wake up the system.
731 int acpi_pm_device_sleep_wake(struct device *dev, bool enable)
733 struct acpi_device *adev;
734 int error;
736 if (!device_can_wakeup(dev))
737 return -EINVAL;
739 adev = ACPI_COMPANION(dev);
740 if (!adev) {
741 dev_dbg(dev, "ACPI companion missing in %s!\n", __func__);
742 return -ENODEV;
745 error = acpi_device_wakeup(adev, acpi_target_system_state(), enable);
746 if (!error)
747 dev_info(dev, "System wakeup %s by ACPI\n",
748 enable ? "enabled" : "disabled");
750 return error;
752 #endif /* CONFIG_PM_SLEEP */
755 * acpi_dev_pm_low_power - Put ACPI device into a low-power state.
756 * @dev: Device to put into a low-power state.
757 * @adev: ACPI device node corresponding to @dev.
758 * @system_state: System state to choose the device state for.
760 static int acpi_dev_pm_low_power(struct device *dev, struct acpi_device *adev,
761 u32 system_state)
763 int ret, state;
765 if (!acpi_device_power_manageable(adev))
766 return 0;
768 ret = acpi_dev_pm_get_state(dev, adev, system_state, NULL, &state);
769 return ret ? ret : acpi_device_set_power(adev, state);
773 * acpi_dev_pm_full_power - Put ACPI device into the full-power state.
774 * @adev: ACPI device node to put into the full-power state.
776 static int acpi_dev_pm_full_power(struct acpi_device *adev)
778 return acpi_device_power_manageable(adev) ?
779 acpi_device_set_power(adev, ACPI_STATE_D0) : 0;
783 * acpi_dev_runtime_suspend - Put device into a low-power state using ACPI.
784 * @dev: Device to put into a low-power state.
786 * Put the given device into a runtime low-power state using the standard ACPI
787 * mechanism. Set up remote wakeup if desired, choose the state to put the
788 * device into (this checks if remote wakeup is expected to work too), and set
789 * the power state of the device.
791 int acpi_dev_runtime_suspend(struct device *dev)
793 struct acpi_device *adev = ACPI_COMPANION(dev);
794 bool remote_wakeup;
795 int error;
797 if (!adev)
798 return 0;
800 remote_wakeup = dev_pm_qos_flags(dev, PM_QOS_FLAG_REMOTE_WAKEUP) >
801 PM_QOS_FLAGS_NONE;
802 error = acpi_device_wakeup(adev, ACPI_STATE_S0, remote_wakeup);
803 if (remote_wakeup && error)
804 return -EAGAIN;
806 error = acpi_dev_pm_low_power(dev, adev, ACPI_STATE_S0);
807 if (error)
808 acpi_device_wakeup(adev, ACPI_STATE_S0, false);
810 return error;
812 EXPORT_SYMBOL_GPL(acpi_dev_runtime_suspend);
815 * acpi_dev_runtime_resume - Put device into the full-power state using ACPI.
816 * @dev: Device to put into the full-power state.
818 * Put the given device into the full-power state using the standard ACPI
819 * mechanism at run time. Set the power state of the device to ACPI D0 and
820 * disable remote wakeup.
822 int acpi_dev_runtime_resume(struct device *dev)
824 struct acpi_device *adev = ACPI_COMPANION(dev);
825 int error;
827 if (!adev)
828 return 0;
830 error = acpi_dev_pm_full_power(adev);
831 acpi_device_wakeup(adev, ACPI_STATE_S0, false);
832 return error;
834 EXPORT_SYMBOL_GPL(acpi_dev_runtime_resume);
837 * acpi_subsys_runtime_suspend - Suspend device using ACPI.
838 * @dev: Device to suspend.
840 * Carry out the generic runtime suspend procedure for @dev and use ACPI to put
841 * it into a runtime low-power state.
843 int acpi_subsys_runtime_suspend(struct device *dev)
845 int ret = pm_generic_runtime_suspend(dev);
846 return ret ? ret : acpi_dev_runtime_suspend(dev);
848 EXPORT_SYMBOL_GPL(acpi_subsys_runtime_suspend);
851 * acpi_subsys_runtime_resume - Resume device using ACPI.
852 * @dev: Device to Resume.
854 * Use ACPI to put the given device into the full-power state and carry out the
855 * generic runtime resume procedure for it.
857 int acpi_subsys_runtime_resume(struct device *dev)
859 int ret = acpi_dev_runtime_resume(dev);
860 return ret ? ret : pm_generic_runtime_resume(dev);
862 EXPORT_SYMBOL_GPL(acpi_subsys_runtime_resume);
864 #ifdef CONFIG_PM_SLEEP
866 * acpi_dev_suspend_late - Put device into a low-power state using ACPI.
867 * @dev: Device to put into a low-power state.
869 * Put the given device into a low-power state during system transition to a
870 * sleep state using the standard ACPI mechanism. Set up system wakeup if
871 * desired, choose the state to put the device into (this checks if system
872 * wakeup is expected to work too), and set the power state of the device.
874 int acpi_dev_suspend_late(struct device *dev)
876 struct acpi_device *adev = ACPI_COMPANION(dev);
877 u32 target_state;
878 bool wakeup;
879 int error;
881 if (!adev)
882 return 0;
884 target_state = acpi_target_system_state();
885 wakeup = device_may_wakeup(dev) && acpi_device_can_wakeup(adev);
886 error = acpi_device_wakeup(adev, target_state, wakeup);
887 if (wakeup && error)
888 return error;
890 error = acpi_dev_pm_low_power(dev, adev, target_state);
891 if (error)
892 acpi_device_wakeup(adev, ACPI_STATE_UNKNOWN, false);
894 return error;
896 EXPORT_SYMBOL_GPL(acpi_dev_suspend_late);
899 * acpi_dev_resume_early - Put device into the full-power state using ACPI.
900 * @dev: Device to put into the full-power state.
902 * Put the given device into the full-power state using the standard ACPI
903 * mechanism during system transition to the working state. Set the power
904 * state of the device to ACPI D0 and disable remote wakeup.
906 int acpi_dev_resume_early(struct device *dev)
908 struct acpi_device *adev = ACPI_COMPANION(dev);
909 int error;
911 if (!adev)
912 return 0;
914 error = acpi_dev_pm_full_power(adev);
915 acpi_device_wakeup(adev, ACPI_STATE_UNKNOWN, false);
916 return error;
918 EXPORT_SYMBOL_GPL(acpi_dev_resume_early);
921 * acpi_subsys_prepare - Prepare device for system transition to a sleep state.
922 * @dev: Device to prepare.
924 int acpi_subsys_prepare(struct device *dev)
926 struct acpi_device *adev = ACPI_COMPANION(dev);
927 u32 sys_target;
928 int ret, state;
930 ret = pm_generic_prepare(dev);
931 if (ret < 0)
932 return ret;
934 if (!adev || !pm_runtime_suspended(dev)
935 || device_may_wakeup(dev) != !!adev->wakeup.prepare_count)
936 return 0;
938 sys_target = acpi_target_system_state();
939 if (sys_target == ACPI_STATE_S0)
940 return 1;
942 if (adev->power.flags.dsw_present)
943 return 0;
945 ret = acpi_dev_pm_get_state(dev, adev, sys_target, NULL, &state);
946 return !ret && state == adev->power.state;
948 EXPORT_SYMBOL_GPL(acpi_subsys_prepare);
951 * acpi_subsys_complete - Finalize device's resume during system resume.
952 * @dev: Device to handle.
954 void acpi_subsys_complete(struct device *dev)
956 pm_generic_complete(dev);
958 * If the device had been runtime-suspended before the system went into
959 * the sleep state it is going out of and it has never been resumed till
960 * now, resume it in case the firmware powered it up.
962 if (dev->power.direct_complete)
963 pm_request_resume(dev);
965 EXPORT_SYMBOL_GPL(acpi_subsys_complete);
968 * acpi_subsys_suspend - Run the device driver's suspend callback.
969 * @dev: Device to handle.
971 * Follow PCI and resume devices suspended at run time before running their
972 * system suspend callbacks.
974 int acpi_subsys_suspend(struct device *dev)
976 pm_runtime_resume(dev);
977 return pm_generic_suspend(dev);
979 EXPORT_SYMBOL_GPL(acpi_subsys_suspend);
982 * acpi_subsys_suspend_late - Suspend device using ACPI.
983 * @dev: Device to suspend.
985 * Carry out the generic late suspend procedure for @dev and use ACPI to put
986 * it into a low-power state during system transition into a sleep state.
988 int acpi_subsys_suspend_late(struct device *dev)
990 int ret = pm_generic_suspend_late(dev);
991 return ret ? ret : acpi_dev_suspend_late(dev);
993 EXPORT_SYMBOL_GPL(acpi_subsys_suspend_late);
996 * acpi_subsys_resume_early - Resume device using ACPI.
997 * @dev: Device to Resume.
999 * Use ACPI to put the given device into the full-power state and carry out the
1000 * generic early resume procedure for it during system transition into the
1001 * working state.
1003 int acpi_subsys_resume_early(struct device *dev)
1005 int ret = acpi_dev_resume_early(dev);
1006 return ret ? ret : pm_generic_resume_early(dev);
1008 EXPORT_SYMBOL_GPL(acpi_subsys_resume_early);
1011 * acpi_subsys_freeze - Run the device driver's freeze callback.
1012 * @dev: Device to handle.
1014 int acpi_subsys_freeze(struct device *dev)
1017 * This used to be done in acpi_subsys_prepare() for all devices and
1018 * some drivers may depend on it, so do it here. Ideally, however,
1019 * runtime-suspended devices should not be touched during freeze/thaw
1020 * transitions.
1022 pm_runtime_resume(dev);
1023 return pm_generic_freeze(dev);
1025 EXPORT_SYMBOL_GPL(acpi_subsys_freeze);
1027 #endif /* CONFIG_PM_SLEEP */
1029 static struct dev_pm_domain acpi_general_pm_domain = {
1030 .ops = {
1031 .runtime_suspend = acpi_subsys_runtime_suspend,
1032 .runtime_resume = acpi_subsys_runtime_resume,
1033 #ifdef CONFIG_PM_SLEEP
1034 .prepare = acpi_subsys_prepare,
1035 .complete = acpi_subsys_complete,
1036 .suspend = acpi_subsys_suspend,
1037 .suspend_late = acpi_subsys_suspend_late,
1038 .resume_early = acpi_subsys_resume_early,
1039 .freeze = acpi_subsys_freeze,
1040 .poweroff = acpi_subsys_suspend,
1041 .poweroff_late = acpi_subsys_suspend_late,
1042 .restore_early = acpi_subsys_resume_early,
1043 #endif
1048 * acpi_dev_pm_detach - Remove ACPI power management from the device.
1049 * @dev: Device to take care of.
1050 * @power_off: Whether or not to try to remove power from the device.
1052 * Remove the device from the general ACPI PM domain and remove its wakeup
1053 * notifier. If @power_off is set, additionally remove power from the device if
1054 * possible.
1056 * Callers must ensure proper synchronization of this function with power
1057 * management callbacks.
1059 static void acpi_dev_pm_detach(struct device *dev, bool power_off)
1061 struct acpi_device *adev = ACPI_COMPANION(dev);
1063 if (adev && dev->pm_domain == &acpi_general_pm_domain) {
1064 dev->pm_domain = NULL;
1065 acpi_remove_pm_notifier(adev);
1066 if (power_off) {
1068 * If the device's PM QoS resume latency limit or flags
1069 * have been exposed to user space, they have to be
1070 * hidden at this point, so that they don't affect the
1071 * choice of the low-power state to put the device into.
1073 dev_pm_qos_hide_latency_limit(dev);
1074 dev_pm_qos_hide_flags(dev);
1075 acpi_device_wakeup(adev, ACPI_STATE_S0, false);
1076 acpi_dev_pm_low_power(dev, adev, ACPI_STATE_S0);
1082 * acpi_dev_pm_attach - Prepare device for ACPI power management.
1083 * @dev: Device to prepare.
1084 * @power_on: Whether or not to power on the device.
1086 * If @dev has a valid ACPI handle that has a valid struct acpi_device object
1087 * attached to it, install a wakeup notification handler for the device and
1088 * add it to the general ACPI PM domain. If @power_on is set, the device will
1089 * be put into the ACPI D0 state before the function returns.
1091 * This assumes that the @dev's bus type uses generic power management callbacks
1092 * (or doesn't use any power management callbacks at all).
1094 * Callers must ensure proper synchronization of this function with power
1095 * management callbacks.
1097 int acpi_dev_pm_attach(struct device *dev, bool power_on)
1099 struct acpi_device *adev = ACPI_COMPANION(dev);
1101 if (!adev)
1102 return -ENODEV;
1104 if (dev->pm_domain)
1105 return -EEXIST;
1107 acpi_add_pm_notifier(adev, dev, acpi_pm_notify_work_func);
1108 dev->pm_domain = &acpi_general_pm_domain;
1109 if (power_on) {
1110 acpi_dev_pm_full_power(adev);
1111 acpi_device_wakeup(adev, ACPI_STATE_S0, false);
1114 dev->pm_domain->detach = acpi_dev_pm_detach;
1115 return 0;
1117 EXPORT_SYMBOL_GPL(acpi_dev_pm_attach);
1118 #endif /* CONFIG_PM */