1 // SPDX-License-Identifier: GPL-2.0-only
3 * drivers/acpi/device_pm.c - ACPI device power management routines.
5 * Copyright (C) 2012, Intel Corp.
6 * Author: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
8 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
10 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
13 #include <linux/acpi.h>
14 #include <linux/export.h>
15 #include <linux/mutex.h>
16 #include <linux/pm_qos.h>
17 #include <linux/pm_domain.h>
18 #include <linux/pm_runtime.h>
19 #include <linux/suspend.h>
23 #define _COMPONENT ACPI_POWER_COMPONENT
24 ACPI_MODULE_NAME("device_pm");
27 * acpi_power_state_string - String representation of ACPI device power state.
28 * @state: ACPI device power state to return the string representation of.
30 const char *acpi_power_state_string(int state)
39 case ACPI_STATE_D3_HOT:
41 case ACPI_STATE_D3_COLD:
49 * acpi_device_get_power - Get power state of an ACPI device.
50 * @device: Device to get the power state of.
51 * @state: Place to store the power state of the device.
53 * This function does not update the device's power.state field, but it may
54 * update its parent's power.state field (when the parent's power state is
55 * unknown and the device's power state turns out to be D0).
57 int acpi_device_get_power(struct acpi_device *device, int *state)
59 int result = ACPI_STATE_UNKNOWN;
61 if (!device || !state)
64 if (!device->flags.power_manageable) {
65 /* TBD: Non-recursive algorithm for walking up hierarchy. */
66 *state = device->parent ?
67 device->parent->power.state : ACPI_STATE_D0;
72 * Get the device's power state from power resources settings and _PSC,
75 if (device->power.flags.power_resources) {
76 int error = acpi_power_get_inferred_state(device, &result);
80 if (device->power.flags.explicit_get) {
81 acpi_handle handle = device->handle;
82 unsigned long long psc;
85 status = acpi_evaluate_integer(handle, "_PSC", NULL, &psc);
86 if (ACPI_FAILURE(status))
90 * The power resources settings may indicate a power state
91 * shallower than the actual power state of the device, because
92 * the same power resources may be referenced by other devices.
94 * For systems predating ACPI 4.0 we assume that D3hot is the
95 * deepest state that can be supported.
97 if (psc > result && psc < ACPI_STATE_D3_COLD)
99 else if (result == ACPI_STATE_UNKNOWN)
100 result = psc > ACPI_STATE_D2 ? ACPI_STATE_D3_HOT : psc;
104 * If we were unsure about the device parent's power state up to this
105 * point, the fact that the device is in D0 implies that the parent has
106 * to be in D0 too, except if ignore_parent is set.
108 if (!device->power.flags.ignore_parent && device->parent
109 && device->parent->power.state == ACPI_STATE_UNKNOWN
110 && result == ACPI_STATE_D0)
111 device->parent->power.state = ACPI_STATE_D0;
116 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device [%s] power state is %s\n",
117 device->pnp.bus_id, acpi_power_state_string(*state)));
121 EXPORT_SYMBOL(acpi_device_get_power);
123 static int acpi_dev_pm_explicit_set(struct acpi_device *adev, int state)
125 if (adev->power.states[state].flags.explicit_set) {
126 char method[5] = { '_', 'P', 'S', '0' + state, '\0' };
129 status = acpi_evaluate_object(adev->handle, method, NULL, NULL);
130 if (ACPI_FAILURE(status))
137 * acpi_device_set_power - Set power state of an ACPI device.
138 * @device: Device to set the power state of.
139 * @state: New power state to set.
141 * Callers must ensure that the device is power manageable before using this
144 int acpi_device_set_power(struct acpi_device *device, int state)
146 int target_state = state;
149 if (!device || !device->flags.power_manageable
150 || (state < ACPI_STATE_D0) || (state > ACPI_STATE_D3_COLD))
153 /* Make sure this is a valid target state */
155 if (state == device->power.state) {
156 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device [%s] already in %s\n",
158 acpi_power_state_string(state)));
162 if (state == ACPI_STATE_D3_COLD) {
164 * For transitions to D3cold we need to execute _PS3 and then
165 * possibly drop references to the power resources in use.
167 state = ACPI_STATE_D3_HOT;
168 /* If _PR3 is not available, use D3hot as the target state. */
169 if (!device->power.states[ACPI_STATE_D3_COLD].flags.valid)
170 target_state = state;
171 } else if (!device->power.states[state].flags.valid) {
172 dev_warn(&device->dev, "Power state %s not supported\n",
173 acpi_power_state_string(state));
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));
189 * In accordance with ACPI 6, _PSx is executed before manipulating power
190 * resources, unless the target state is D0, in which case _PS0 is
191 * supposed to be executed after turning the power resources on.
193 if (state > ACPI_STATE_D0) {
195 * According to ACPI 6, devices cannot go from lower-power
196 * (deeper) states to higher-power (shallower) states.
198 if (state < device->power.state) {
199 dev_warn(&device->dev, "Cannot transition from %s to %s\n",
200 acpi_power_state_string(device->power.state),
201 acpi_power_state_string(state));
205 result = acpi_dev_pm_explicit_set(device, state);
209 if (device->power.flags.power_resources)
210 result = acpi_power_transition(device, target_state);
212 if (device->power.flags.power_resources) {
213 result = acpi_power_transition(device, ACPI_STATE_D0);
217 result = acpi_dev_pm_explicit_set(device, ACPI_STATE_D0);
222 dev_warn(&device->dev, "Failed to change power state to %s\n",
223 acpi_power_state_string(state));
225 device->power.state = target_state;
226 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
227 "Device [%s] transitioned to %s\n",
229 acpi_power_state_string(state)));
234 EXPORT_SYMBOL(acpi_device_set_power);
236 int acpi_bus_set_power(acpi_handle handle, int state)
238 struct acpi_device *device;
241 result = acpi_bus_get_device(handle, &device);
245 return acpi_device_set_power(device, state);
247 EXPORT_SYMBOL(acpi_bus_set_power);
249 int acpi_bus_init_power(struct acpi_device *device)
257 device->power.state = ACPI_STATE_UNKNOWN;
258 if (!acpi_device_is_present(device)) {
259 device->flags.initialized = false;
263 result = acpi_device_get_power(device, &state);
267 if (state < ACPI_STATE_D3_COLD && device->power.flags.power_resources) {
268 /* Reference count the power resources. */
269 result = acpi_power_on_resources(device, state);
273 if (state == ACPI_STATE_D0) {
275 * If _PSC is not present and the state inferred from
276 * power resources appears to be D0, it still may be
277 * necessary to execute _PS0 at this point, because
278 * another device using the same power resources may
279 * have been put into D0 previously and that's why we
282 result = acpi_dev_pm_explicit_set(device, state);
286 } else if (state == ACPI_STATE_UNKNOWN) {
288 * No power resources and missing _PSC? Cross fingers and make
289 * it D0 in hope that this is what the BIOS put the device into.
290 * [We tried to force D0 here by executing _PS0, but that broke
291 * Toshiba P870-303 in a nasty way.]
293 state = ACPI_STATE_D0;
295 device->power.state = state;
300 * acpi_device_fix_up_power - Force device with missing _PSC into D0.
301 * @device: Device object whose power state is to be fixed up.
303 * Devices without power resources and _PSC, but having _PS0 and _PS3 defined,
304 * are assumed to be put into D0 by the BIOS. However, in some cases that may
305 * not be the case and this function should be used then.
307 int acpi_device_fix_up_power(struct acpi_device *device)
311 if (!device->power.flags.power_resources
312 && !device->power.flags.explicit_get
313 && device->power.state == ACPI_STATE_D0)
314 ret = acpi_dev_pm_explicit_set(device, ACPI_STATE_D0);
318 EXPORT_SYMBOL_GPL(acpi_device_fix_up_power);
320 int acpi_device_update_power(struct acpi_device *device, int *state_p)
325 if (device->power.state == ACPI_STATE_UNKNOWN) {
326 result = acpi_bus_init_power(device);
327 if (!result && state_p)
328 *state_p = device->power.state;
333 result = acpi_device_get_power(device, &state);
337 if (state == ACPI_STATE_UNKNOWN) {
338 state = ACPI_STATE_D0;
339 result = acpi_device_set_power(device, state);
343 if (device->power.flags.power_resources) {
345 * We don't need to really switch the state, bu we need
346 * to update the power resources' reference counters.
348 result = acpi_power_transition(device, state);
352 device->power.state = state;
359 EXPORT_SYMBOL_GPL(acpi_device_update_power);
361 int acpi_bus_update_power(acpi_handle handle, int *state_p)
363 struct acpi_device *device;
366 result = acpi_bus_get_device(handle, &device);
367 return result ? result : acpi_device_update_power(device, state_p);
369 EXPORT_SYMBOL_GPL(acpi_bus_update_power);
371 bool acpi_bus_power_manageable(acpi_handle handle)
373 struct acpi_device *device;
376 result = acpi_bus_get_device(handle, &device);
377 return result ? false : device->flags.power_manageable;
379 EXPORT_SYMBOL(acpi_bus_power_manageable);
382 static DEFINE_MUTEX(acpi_pm_notifier_lock);
383 static DEFINE_MUTEX(acpi_pm_notifier_install_lock);
385 void acpi_pm_wakeup_event(struct device *dev)
387 pm_wakeup_dev_event(dev, 0, acpi_s2idle_wakeup());
389 EXPORT_SYMBOL_GPL(acpi_pm_wakeup_event);
391 static void acpi_pm_notify_handler(acpi_handle handle, u32 val, void *not_used)
393 struct acpi_device *adev;
395 if (val != ACPI_NOTIFY_DEVICE_WAKE)
398 acpi_handle_debug(handle, "Wake notify\n");
400 adev = acpi_bus_get_acpi_device(handle);
404 mutex_lock(&acpi_pm_notifier_lock);
406 if (adev->wakeup.flags.notifier_present) {
407 pm_wakeup_ws_event(adev->wakeup.ws, 0, acpi_s2idle_wakeup());
408 if (adev->wakeup.context.func) {
409 acpi_handle_debug(handle, "Running %pS for %s\n",
410 adev->wakeup.context.func,
411 dev_name(adev->wakeup.context.dev));
412 adev->wakeup.context.func(&adev->wakeup.context);
416 mutex_unlock(&acpi_pm_notifier_lock);
418 acpi_bus_put_acpi_device(adev);
422 * acpi_add_pm_notifier - Register PM notify handler for given ACPI device.
423 * @adev: ACPI device to add the notify handler for.
424 * @dev: Device to generate a wakeup event for while handling the notification.
425 * @func: Work function to execute when handling the notification.
427 * NOTE: @adev need not be a run-wake or wakeup device to be a valid source of
428 * PM wakeup events. For example, wakeup events may be generated for bridges
429 * if one of the devices below the bridge is signaling wakeup, even if the
430 * bridge itself doesn't have a wakeup GPE associated with it.
432 acpi_status acpi_add_pm_notifier(struct acpi_device *adev, struct device *dev,
433 void (*func)(struct acpi_device_wakeup_context *context))
435 acpi_status status = AE_ALREADY_EXISTS;
438 return AE_BAD_PARAMETER;
440 mutex_lock(&acpi_pm_notifier_install_lock);
442 if (adev->wakeup.flags.notifier_present)
445 status = acpi_install_notify_handler(adev->handle, ACPI_SYSTEM_NOTIFY,
446 acpi_pm_notify_handler, NULL);
447 if (ACPI_FAILURE(status))
450 mutex_lock(&acpi_pm_notifier_lock);
451 adev->wakeup.ws = wakeup_source_register(dev_name(&adev->dev));
452 adev->wakeup.context.dev = dev;
453 adev->wakeup.context.func = func;
454 adev->wakeup.flags.notifier_present = true;
455 mutex_unlock(&acpi_pm_notifier_lock);
458 mutex_unlock(&acpi_pm_notifier_install_lock);
463 * acpi_remove_pm_notifier - Unregister PM notifier from given ACPI device.
464 * @adev: ACPI device to remove the notifier from.
466 acpi_status acpi_remove_pm_notifier(struct acpi_device *adev)
468 acpi_status status = AE_BAD_PARAMETER;
470 mutex_lock(&acpi_pm_notifier_install_lock);
472 if (!adev->wakeup.flags.notifier_present)
475 status = acpi_remove_notify_handler(adev->handle,
477 acpi_pm_notify_handler);
478 if (ACPI_FAILURE(status))
481 mutex_lock(&acpi_pm_notifier_lock);
482 adev->wakeup.context.func = NULL;
483 adev->wakeup.context.dev = NULL;
484 wakeup_source_unregister(adev->wakeup.ws);
485 adev->wakeup.flags.notifier_present = false;
486 mutex_unlock(&acpi_pm_notifier_lock);
489 mutex_unlock(&acpi_pm_notifier_install_lock);
493 bool acpi_bus_can_wakeup(acpi_handle handle)
495 struct acpi_device *device;
498 result = acpi_bus_get_device(handle, &device);
499 return result ? false : device->wakeup.flags.valid;
501 EXPORT_SYMBOL(acpi_bus_can_wakeup);
503 bool acpi_pm_device_can_wakeup(struct device *dev)
505 struct acpi_device *adev = ACPI_COMPANION(dev);
507 return adev ? acpi_device_can_wakeup(adev) : false;
511 * acpi_dev_pm_get_state - Get preferred power state of ACPI device.
512 * @dev: Device whose preferred target power state to return.
513 * @adev: ACPI device node corresponding to @dev.
514 * @target_state: System state to match the resultant device state.
515 * @d_min_p: Location to store the highest power state available to the device.
516 * @d_max_p: Location to store the lowest power state available to the device.
518 * Find the lowest power (highest number) and highest power (lowest number) ACPI
519 * device power states that the device can be in while the system is in the
520 * state represented by @target_state. Store the integer numbers representing
521 * those stats in the memory locations pointed to by @d_max_p and @d_min_p,
524 * Callers must ensure that @dev and @adev are valid pointers and that @adev
525 * actually corresponds to @dev before using this function.
527 * Returns 0 on success or -ENODATA when one of the ACPI methods fails or
528 * returns a value that doesn't make sense. The memory locations pointed to by
529 * @d_max_p and @d_min_p are only modified on success.
531 static int acpi_dev_pm_get_state(struct device *dev, struct acpi_device *adev,
532 u32 target_state, int *d_min_p, int *d_max_p)
534 char method[] = { '_', 'S', '0' + target_state, 'D', '\0' };
535 acpi_handle handle = adev->handle;
536 unsigned long long ret;
539 bool has_sxd = false;
543 * If the system state is S0, the lowest power state the device can be
544 * in is D3cold, unless the device has _S0W and is supposed to signal
545 * wakeup, in which case the return value of _S0W has to be used as the
546 * lowest power state available to the device.
548 d_min = ACPI_STATE_D0;
549 d_max = ACPI_STATE_D3_COLD;
552 * If present, _SxD methods return the minimum D-state (highest power
553 * state) we can use for the corresponding S-states. Otherwise, the
554 * minimum D-state is D0 (ACPI 3.x).
556 if (target_state > ACPI_STATE_S0) {
558 * We rely on acpi_evaluate_integer() not clobbering the integer
559 * provided if AE_NOT_FOUND is returned.
562 status = acpi_evaluate_integer(handle, method, NULL, &ret);
563 if ((ACPI_FAILURE(status) && status != AE_NOT_FOUND)
564 || ret > ACPI_STATE_D3_COLD)
568 * We need to handle legacy systems where D3hot and D3cold are
569 * the same and 3 is returned in both cases, so fall back to
570 * D3cold if D3hot is not a valid state.
572 if (!adev->power.states[ret].flags.valid) {
573 if (ret == ACPI_STATE_D3_HOT)
574 ret = ACPI_STATE_D3_COLD;
583 wakeup = device_may_wakeup(dev) && adev->wakeup.flags.valid
584 && adev->wakeup.sleep_state >= target_state;
586 wakeup = adev->wakeup.flags.valid;
590 * If _PRW says we can wake up the system from the target sleep state,
591 * the D-state returned by _SxD is sufficient for that (we assume a
592 * wakeup-aware driver if wake is set). Still, if _SxW exists
593 * (ACPI 3.x), it should return the maximum (lowest power) D-state that
594 * can wake the system. _S0W may be valid, too.
598 status = acpi_evaluate_integer(handle, method, NULL, &ret);
599 if (status == AE_NOT_FOUND) {
600 /* No _SxW. In this case, the ACPI spec says that we
601 * must not go into any power state deeper than the
602 * value returned from _SxD.
604 if (has_sxd && target_state > ACPI_STATE_S0)
606 } else if (ACPI_SUCCESS(status) && ret <= ACPI_STATE_D3_COLD) {
607 /* Fall back to D3cold if ret is not a valid state. */
608 if (!adev->power.states[ret].flags.valid)
609 ret = ACPI_STATE_D3_COLD;
611 d_max = ret > d_min ? ret : d_min;
627 * acpi_pm_device_sleep_state - Get preferred power state of ACPI device.
628 * @dev: Device whose preferred target power state to return.
629 * @d_min_p: Location to store the upper limit of the allowed states range.
630 * @d_max_in: Deepest low-power state to take into consideration.
631 * Return value: Preferred power state of the device on success, -ENODEV
632 * if there's no 'struct acpi_device' for @dev, -EINVAL if @d_max_in is
633 * incorrect, or -ENODATA on ACPI method failure.
635 * The caller must ensure that @dev is valid before using this function.
637 int acpi_pm_device_sleep_state(struct device *dev, int *d_min_p, int d_max_in)
639 struct acpi_device *adev;
640 int ret, d_min, d_max;
642 if (d_max_in < ACPI_STATE_D0 || d_max_in > ACPI_STATE_D3_COLD)
645 if (d_max_in > ACPI_STATE_D2) {
646 enum pm_qos_flags_status stat;
648 stat = dev_pm_qos_flags(dev, PM_QOS_FLAG_NO_POWER_OFF);
649 if (stat == PM_QOS_FLAGS_ALL)
650 d_max_in = ACPI_STATE_D2;
653 adev = ACPI_COMPANION(dev);
655 dev_dbg(dev, "ACPI companion missing in %s!\n", __func__);
659 ret = acpi_dev_pm_get_state(dev, adev, acpi_target_system_state(),
664 if (d_max_in < d_min)
667 if (d_max > d_max_in) {
668 for (d_max = d_max_in; d_max > d_min; d_max--) {
669 if (adev->power.states[d_max].flags.valid)
679 EXPORT_SYMBOL(acpi_pm_device_sleep_state);
682 * acpi_pm_notify_work_func - ACPI devices wakeup notification work function.
683 * @context: Device wakeup context.
685 static void acpi_pm_notify_work_func(struct acpi_device_wakeup_context *context)
687 struct device *dev = context->dev;
690 pm_wakeup_event(dev, 0);
691 pm_request_resume(dev);
695 static DEFINE_MUTEX(acpi_wakeup_lock);
697 static int __acpi_device_wakeup_enable(struct acpi_device *adev,
698 u32 target_state, int max_count)
700 struct acpi_device_wakeup *wakeup = &adev->wakeup;
704 mutex_lock(&acpi_wakeup_lock);
706 if (wakeup->enable_count >= max_count)
709 if (wakeup->enable_count > 0)
712 error = acpi_enable_wakeup_device_power(adev, target_state);
716 status = acpi_enable_gpe(wakeup->gpe_device, wakeup->gpe_number);
717 if (ACPI_FAILURE(status)) {
718 acpi_disable_wakeup_device_power(adev);
723 acpi_handle_debug(adev->handle, "GPE%2X enabled for wakeup\n",
724 (unsigned int)wakeup->gpe_number);
727 wakeup->enable_count++;
730 mutex_unlock(&acpi_wakeup_lock);
735 * acpi_device_wakeup_enable - Enable wakeup functionality for device.
736 * @adev: ACPI device to enable wakeup functionality for.
737 * @target_state: State the system is transitioning into.
739 * Enable the GPE associated with @adev so that it can generate wakeup signals
740 * for the device in response to external (remote) events and enable wakeup
743 * Callers must ensure that @adev is a valid ACPI device node before executing
746 static int acpi_device_wakeup_enable(struct acpi_device *adev, u32 target_state)
748 return __acpi_device_wakeup_enable(adev, target_state, 1);
752 * acpi_device_wakeup_disable - Disable wakeup functionality for device.
753 * @adev: ACPI device to disable wakeup functionality for.
755 * Disable the GPE associated with @adev and disable wakeup power for it.
757 * Callers must ensure that @adev is a valid ACPI device node before executing
760 static void acpi_device_wakeup_disable(struct acpi_device *adev)
762 struct acpi_device_wakeup *wakeup = &adev->wakeup;
764 mutex_lock(&acpi_wakeup_lock);
766 if (!wakeup->enable_count)
769 acpi_disable_gpe(wakeup->gpe_device, wakeup->gpe_number);
770 acpi_disable_wakeup_device_power(adev);
772 wakeup->enable_count--;
775 mutex_unlock(&acpi_wakeup_lock);
778 static int __acpi_pm_set_device_wakeup(struct device *dev, bool enable,
781 struct acpi_device *adev;
784 adev = ACPI_COMPANION(dev);
786 dev_dbg(dev, "ACPI companion missing in %s!\n", __func__);
790 if (!acpi_device_can_wakeup(adev))
794 acpi_device_wakeup_disable(adev);
795 dev_dbg(dev, "Wakeup disabled by ACPI\n");
799 error = __acpi_device_wakeup_enable(adev, acpi_target_system_state(),
802 dev_dbg(dev, "Wakeup enabled by ACPI\n");
808 * acpi_pm_set_device_wakeup - Enable/disable remote wakeup for given device.
809 * @dev: Device to enable/disable to generate wakeup events.
810 * @enable: Whether to enable or disable the wakeup functionality.
812 int acpi_pm_set_device_wakeup(struct device *dev, bool enable)
814 return __acpi_pm_set_device_wakeup(dev, enable, 1);
816 EXPORT_SYMBOL_GPL(acpi_pm_set_device_wakeup);
819 * acpi_pm_set_bridge_wakeup - Enable/disable remote wakeup for given bridge.
820 * @dev: Bridge device to enable/disable to generate wakeup events.
821 * @enable: Whether to enable or disable the wakeup functionality.
823 int acpi_pm_set_bridge_wakeup(struct device *dev, bool enable)
825 return __acpi_pm_set_device_wakeup(dev, enable, INT_MAX);
827 EXPORT_SYMBOL_GPL(acpi_pm_set_bridge_wakeup);
830 * acpi_dev_pm_low_power - Put ACPI device into a low-power state.
831 * @dev: Device to put into a low-power state.
832 * @adev: ACPI device node corresponding to @dev.
833 * @system_state: System state to choose the device state for.
835 static int acpi_dev_pm_low_power(struct device *dev, struct acpi_device *adev,
840 if (!acpi_device_power_manageable(adev))
843 ret = acpi_dev_pm_get_state(dev, adev, system_state, NULL, &state);
844 return ret ? ret : acpi_device_set_power(adev, state);
848 * acpi_dev_pm_full_power - Put ACPI device into the full-power state.
849 * @adev: ACPI device node to put into the full-power state.
851 static int acpi_dev_pm_full_power(struct acpi_device *adev)
853 return acpi_device_power_manageable(adev) ?
854 acpi_device_set_power(adev, ACPI_STATE_D0) : 0;
858 * acpi_dev_suspend - Put device into a low-power state using ACPI.
859 * @dev: Device to put into a low-power state.
860 * @wakeup: Whether or not to enable wakeup for the device.
862 * Put the given device into a low-power state using the standard ACPI
863 * mechanism. Set up remote wakeup if desired, choose the state to put the
864 * device into (this checks if remote wakeup is expected to work too), and set
865 * the power state of the device.
867 int acpi_dev_suspend(struct device *dev, bool wakeup)
869 struct acpi_device *adev = ACPI_COMPANION(dev);
870 u32 target_state = acpi_target_system_state();
876 if (wakeup && acpi_device_can_wakeup(adev)) {
877 error = acpi_device_wakeup_enable(adev, target_state);
884 error = acpi_dev_pm_low_power(dev, adev, target_state);
886 acpi_device_wakeup_disable(adev);
890 EXPORT_SYMBOL_GPL(acpi_dev_suspend);
893 * acpi_dev_resume - Put device into the full-power state using ACPI.
894 * @dev: Device to put into the full-power state.
896 * Put the given device into the full-power state using the standard ACPI
897 * mechanism. Set the power state of the device to ACPI D0 and disable wakeup.
899 int acpi_dev_resume(struct device *dev)
901 struct acpi_device *adev = ACPI_COMPANION(dev);
907 error = acpi_dev_pm_full_power(adev);
908 acpi_device_wakeup_disable(adev);
911 EXPORT_SYMBOL_GPL(acpi_dev_resume);
914 * acpi_subsys_runtime_suspend - Suspend device using ACPI.
915 * @dev: Device to suspend.
917 * Carry out the generic runtime suspend procedure for @dev and use ACPI to put
918 * it into a runtime low-power state.
920 int acpi_subsys_runtime_suspend(struct device *dev)
922 int ret = pm_generic_runtime_suspend(dev);
923 return ret ? ret : acpi_dev_suspend(dev, true);
925 EXPORT_SYMBOL_GPL(acpi_subsys_runtime_suspend);
928 * acpi_subsys_runtime_resume - Resume device using ACPI.
929 * @dev: Device to Resume.
931 * Use ACPI to put the given device into the full-power state and carry out the
932 * generic runtime resume procedure for it.
934 int acpi_subsys_runtime_resume(struct device *dev)
936 int ret = acpi_dev_resume(dev);
937 return ret ? ret : pm_generic_runtime_resume(dev);
939 EXPORT_SYMBOL_GPL(acpi_subsys_runtime_resume);
941 #ifdef CONFIG_PM_SLEEP
942 static bool acpi_dev_needs_resume(struct device *dev, struct acpi_device *adev)
944 u32 sys_target = acpi_target_system_state();
947 if (!pm_runtime_suspended(dev) || !adev || (adev->wakeup.flags.valid &&
948 device_may_wakeup(dev) != !!adev->wakeup.prepare_count))
951 if (sys_target == ACPI_STATE_S0)
954 if (adev->power.flags.dsw_present)
957 ret = acpi_dev_pm_get_state(dev, adev, sys_target, NULL, &state);
961 return state != adev->power.state;
965 * acpi_subsys_prepare - Prepare device for system transition to a sleep state.
966 * @dev: Device to prepare.
968 int acpi_subsys_prepare(struct device *dev)
970 struct acpi_device *adev = ACPI_COMPANION(dev);
972 if (dev->driver && dev->driver->pm && dev->driver->pm->prepare) {
973 int ret = dev->driver->pm->prepare(dev);
978 if (!ret && dev_pm_test_driver_flags(dev, DPM_FLAG_SMART_PREPARE))
982 return !acpi_dev_needs_resume(dev, adev);
984 EXPORT_SYMBOL_GPL(acpi_subsys_prepare);
987 * acpi_subsys_complete - Finalize device's resume during system resume.
988 * @dev: Device to handle.
990 void acpi_subsys_complete(struct device *dev)
992 pm_generic_complete(dev);
994 * If the device had been runtime-suspended before the system went into
995 * the sleep state it is going out of and it has never been resumed till
996 * now, resume it in case the firmware powered it up.
998 if (pm_runtime_suspended(dev) && pm_resume_via_firmware())
999 pm_request_resume(dev);
1001 EXPORT_SYMBOL_GPL(acpi_subsys_complete);
1004 * acpi_subsys_suspend - Run the device driver's suspend callback.
1005 * @dev: Device to handle.
1007 * Follow PCI and resume devices from runtime suspend before running their
1008 * system suspend callbacks, unless the driver can cope with runtime-suspended
1009 * devices during system suspend and there are no ACPI-specific reasons for
1012 int acpi_subsys_suspend(struct device *dev)
1014 if (!dev_pm_test_driver_flags(dev, DPM_FLAG_SMART_SUSPEND) ||
1015 acpi_dev_needs_resume(dev, ACPI_COMPANION(dev)))
1016 pm_runtime_resume(dev);
1018 return pm_generic_suspend(dev);
1020 EXPORT_SYMBOL_GPL(acpi_subsys_suspend);
1023 * acpi_subsys_suspend_late - Suspend device using ACPI.
1024 * @dev: Device to suspend.
1026 * Carry out the generic late suspend procedure for @dev and use ACPI to put
1027 * it into a low-power state during system transition into a sleep state.
1029 int acpi_subsys_suspend_late(struct device *dev)
1033 if (dev_pm_smart_suspend_and_suspended(dev))
1036 ret = pm_generic_suspend_late(dev);
1037 return ret ? ret : acpi_dev_suspend(dev, device_may_wakeup(dev));
1039 EXPORT_SYMBOL_GPL(acpi_subsys_suspend_late);
1042 * acpi_subsys_suspend_noirq - Run the device driver's "noirq" suspend callback.
1043 * @dev: Device to suspend.
1045 int acpi_subsys_suspend_noirq(struct device *dev)
1049 if (dev_pm_smart_suspend_and_suspended(dev)) {
1050 dev->power.may_skip_resume = true;
1054 ret = pm_generic_suspend_noirq(dev);
1059 * If the target system sleep state is suspend-to-idle, it is sufficient
1060 * to check whether or not the device's wakeup settings are good for
1061 * runtime PM. Otherwise, the pm_resume_via_firmware() check will cause
1062 * acpi_subsys_complete() to take care of fixing up the device's state
1063 * anyway, if need be.
1065 dev->power.may_skip_resume = device_may_wakeup(dev) ||
1066 !device_can_wakeup(dev);
1070 EXPORT_SYMBOL_GPL(acpi_subsys_suspend_noirq);
1073 * acpi_subsys_resume_noirq - Run the device driver's "noirq" resume callback.
1074 * @dev: Device to handle.
1076 int acpi_subsys_resume_noirq(struct device *dev)
1078 if (dev_pm_may_skip_resume(dev))
1082 * Devices with DPM_FLAG_SMART_SUSPEND may be left in runtime suspend
1083 * during system suspend, so update their runtime PM status to "active"
1084 * as they will be put into D0 going forward.
1086 if (dev_pm_smart_suspend_and_suspended(dev))
1087 pm_runtime_set_active(dev);
1089 return pm_generic_resume_noirq(dev);
1091 EXPORT_SYMBOL_GPL(acpi_subsys_resume_noirq);
1094 * acpi_subsys_resume_early - Resume device using ACPI.
1095 * @dev: Device to Resume.
1097 * Use ACPI to put the given device into the full-power state and carry out the
1098 * generic early resume procedure for it during system transition into the
1101 int acpi_subsys_resume_early(struct device *dev)
1103 int ret = acpi_dev_resume(dev);
1104 return ret ? ret : pm_generic_resume_early(dev);
1106 EXPORT_SYMBOL_GPL(acpi_subsys_resume_early);
1109 * acpi_subsys_freeze - Run the device driver's freeze callback.
1110 * @dev: Device to handle.
1112 int acpi_subsys_freeze(struct device *dev)
1115 * This used to be done in acpi_subsys_prepare() for all devices and
1116 * some drivers may depend on it, so do it here. Ideally, however,
1117 * runtime-suspended devices should not be touched during freeze/thaw
1120 if (!dev_pm_test_driver_flags(dev, DPM_FLAG_SMART_SUSPEND))
1121 pm_runtime_resume(dev);
1123 return pm_generic_freeze(dev);
1125 EXPORT_SYMBOL_GPL(acpi_subsys_freeze);
1128 * acpi_subsys_freeze_late - Run the device driver's "late" freeze callback.
1129 * @dev: Device to handle.
1131 int acpi_subsys_freeze_late(struct device *dev)
1134 if (dev_pm_smart_suspend_and_suspended(dev))
1137 return pm_generic_freeze_late(dev);
1139 EXPORT_SYMBOL_GPL(acpi_subsys_freeze_late);
1142 * acpi_subsys_freeze_noirq - Run the device driver's "noirq" freeze callback.
1143 * @dev: Device to handle.
1145 int acpi_subsys_freeze_noirq(struct device *dev)
1148 if (dev_pm_smart_suspend_and_suspended(dev))
1151 return pm_generic_freeze_noirq(dev);
1153 EXPORT_SYMBOL_GPL(acpi_subsys_freeze_noirq);
1156 * acpi_subsys_thaw_noirq - Run the device driver's "noirq" thaw callback.
1157 * @dev: Device to handle.
1159 int acpi_subsys_thaw_noirq(struct device *dev)
1162 * If the device is in runtime suspend, the "thaw" code may not work
1163 * correctly with it, so skip the driver callback and make the PM core
1164 * skip all of the subsequent "thaw" callbacks for the device.
1166 if (dev_pm_smart_suspend_and_suspended(dev)) {
1167 dev_pm_skip_next_resume_phases(dev);
1171 return pm_generic_thaw_noirq(dev);
1173 EXPORT_SYMBOL_GPL(acpi_subsys_thaw_noirq);
1174 #endif /* CONFIG_PM_SLEEP */
1176 static struct dev_pm_domain acpi_general_pm_domain = {
1178 .runtime_suspend = acpi_subsys_runtime_suspend,
1179 .runtime_resume = acpi_subsys_runtime_resume,
1180 #ifdef CONFIG_PM_SLEEP
1181 .prepare = acpi_subsys_prepare,
1182 .complete = acpi_subsys_complete,
1183 .suspend = acpi_subsys_suspend,
1184 .suspend_late = acpi_subsys_suspend_late,
1185 .suspend_noirq = acpi_subsys_suspend_noirq,
1186 .resume_noirq = acpi_subsys_resume_noirq,
1187 .resume_early = acpi_subsys_resume_early,
1188 .freeze = acpi_subsys_freeze,
1189 .freeze_late = acpi_subsys_freeze_late,
1190 .freeze_noirq = acpi_subsys_freeze_noirq,
1191 .thaw_noirq = acpi_subsys_thaw_noirq,
1192 .poweroff = acpi_subsys_suspend,
1193 .poweroff_late = acpi_subsys_suspend_late,
1194 .poweroff_noirq = acpi_subsys_suspend_noirq,
1195 .restore_noirq = acpi_subsys_resume_noirq,
1196 .restore_early = acpi_subsys_resume_early,
1202 * acpi_dev_pm_detach - Remove ACPI power management from the device.
1203 * @dev: Device to take care of.
1204 * @power_off: Whether or not to try to remove power from the device.
1206 * Remove the device from the general ACPI PM domain and remove its wakeup
1207 * notifier. If @power_off is set, additionally remove power from the device if
1210 * Callers must ensure proper synchronization of this function with power
1211 * management callbacks.
1213 static void acpi_dev_pm_detach(struct device *dev, bool power_off)
1215 struct acpi_device *adev = ACPI_COMPANION(dev);
1217 if (adev && dev->pm_domain == &acpi_general_pm_domain) {
1218 dev_pm_domain_set(dev, NULL);
1219 acpi_remove_pm_notifier(adev);
1222 * If the device's PM QoS resume latency limit or flags
1223 * have been exposed to user space, they have to be
1224 * hidden at this point, so that they don't affect the
1225 * choice of the low-power state to put the device into.
1227 dev_pm_qos_hide_latency_limit(dev);
1228 dev_pm_qos_hide_flags(dev);
1229 acpi_device_wakeup_disable(adev);
1230 acpi_dev_pm_low_power(dev, adev, ACPI_STATE_S0);
1236 * acpi_dev_pm_attach - Prepare device for ACPI power management.
1237 * @dev: Device to prepare.
1238 * @power_on: Whether or not to power on the device.
1240 * If @dev has a valid ACPI handle that has a valid struct acpi_device object
1241 * attached to it, install a wakeup notification handler for the device and
1242 * add it to the general ACPI PM domain. If @power_on is set, the device will
1243 * be put into the ACPI D0 state before the function returns.
1245 * This assumes that the @dev's bus type uses generic power management callbacks
1246 * (or doesn't use any power management callbacks at all).
1248 * Callers must ensure proper synchronization of this function with power
1249 * management callbacks.
1251 int acpi_dev_pm_attach(struct device *dev, bool power_on)
1253 struct acpi_device *adev = ACPI_COMPANION(dev);
1259 * Only attach the power domain to the first device if the
1260 * companion is shared by multiple. This is to prevent doing power
1263 if (!acpi_device_is_first_physical_node(adev, dev))
1266 acpi_add_pm_notifier(adev, dev, acpi_pm_notify_work_func);
1267 dev_pm_domain_set(dev, &acpi_general_pm_domain);
1269 acpi_dev_pm_full_power(adev);
1270 acpi_device_wakeup_disable(adev);
1273 dev->pm_domain->detach = acpi_dev_pm_detach;
1276 EXPORT_SYMBOL_GPL(acpi_dev_pm_attach);
1277 #endif /* CONFIG_PM */