mirror of
https://github.com/torvalds/linux.git
synced 2026-03-08 03:24:45 +01:00
Merge branch 'clk-pm' into clk-next
* clk-pm: clk: qcom: Remove redundant pm_runtime_mark_last_busy() calls clk: imx: Remove redundant pm_runtime_mark_last_busy() calls Documentation: PM: *_autosuspend() functions update last busy time PM: runtime: Mark last busy stamp in pm_request_autosuspend() PM: runtime: Mark last busy stamp in pm_runtime_autosuspend() PM: runtime: Mark last busy stamp in pm_runtime_put_sync_autosuspend() PM: runtime: Mark last busy stamp in pm_runtime_put_autosuspend() PM: runtime: Document return values of suspend-related API functions
This commit is contained in:
Stephen Boyd
commit
3cf186ecc1
6 changed files with 186 additions and 57 deletions
|
|
@ -154,11 +154,9 @@ suspending the device are satisfied) and to queue up a suspend request for the
|
|||
device in that case. If there is no idle callback, or if the callback returns
|
||||
0, then the PM core will attempt to carry out a runtime suspend of the device,
|
||||
also respecting devices configured for autosuspend. In essence this means a
|
||||
call to pm_runtime_autosuspend() (do note that drivers needs to update the
|
||||
device last busy mark, pm_runtime_mark_last_busy(), to control the delay under
|
||||
this circumstance). To prevent this (for example, if the callback routine has
|
||||
started a delayed suspend), the routine must return a non-zero value. Negative
|
||||
error return codes are ignored by the PM core.
|
||||
call to pm_runtime_autosuspend(). To prevent this (for example, if the callback
|
||||
routine has started a delayed suspend), the routine must return a non-zero
|
||||
value. Negative error return codes are ignored by the PM core.
|
||||
|
||||
The helper functions provided by the PM core, described in Section 4, guarantee
|
||||
that the following constraints are met with respect to runtime PM callbacks for
|
||||
|
|
@ -330,10 +328,9 @@ drivers/base/power/runtime.c and include/linux/pm_runtime.h:
|
|||
'power.disable_depth' is different from 0
|
||||
|
||||
`int pm_runtime_autosuspend(struct device *dev);`
|
||||
- same as pm_runtime_suspend() except that the autosuspend delay is taken
|
||||
`into account;` if pm_runtime_autosuspend_expiration() says the delay has
|
||||
not yet expired then an autosuspend is scheduled for the appropriate time
|
||||
and 0 is returned
|
||||
- same as pm_runtime_suspend() except that a call to
|
||||
pm_runtime_mark_last_busy() is made and an autosuspend is scheduled for
|
||||
the appropriate time and 0 is returned
|
||||
|
||||
`int pm_runtime_resume(struct device *dev);`
|
||||
- execute the subsystem-level resume callback for the device; returns 0 on
|
||||
|
|
@ -357,9 +354,9 @@ drivers/base/power/runtime.c and include/linux/pm_runtime.h:
|
|||
success or error code if the request has not been queued up
|
||||
|
||||
`int pm_request_autosuspend(struct device *dev);`
|
||||
- schedule the execution of the subsystem-level suspend callback for the
|
||||
device when the autosuspend delay has expired; if the delay has already
|
||||
expired then the work item is queued up immediately
|
||||
- Call pm_runtime_mark_last_busy() and schedule the execution of the
|
||||
subsystem-level suspend callback for the device when the autosuspend delay
|
||||
expires
|
||||
|
||||
`int pm_schedule_suspend(struct device *dev, unsigned int delay);`
|
||||
- schedule the execution of the subsystem-level suspend callback for the
|
||||
|
|
@ -411,8 +408,9 @@ drivers/base/power/runtime.c and include/linux/pm_runtime.h:
|
|||
pm_request_idle(dev) and return its result
|
||||
|
||||
`int pm_runtime_put_autosuspend(struct device *dev);`
|
||||
- does the same as __pm_runtime_put_autosuspend() for now, but in the
|
||||
future, will also call pm_runtime_mark_last_busy() as well, DO NOT USE!
|
||||
- set the power.last_busy field to the current time and decrement the
|
||||
device's usage counter; if the result is 0 then run
|
||||
pm_request_autosuspend(dev) and return its result
|
||||
|
||||
`int __pm_runtime_put_autosuspend(struct device *dev);`
|
||||
- decrement the device's usage counter; if the result is 0 then run
|
||||
|
|
@ -427,7 +425,8 @@ drivers/base/power/runtime.c and include/linux/pm_runtime.h:
|
|||
pm_runtime_suspend(dev) and return its result
|
||||
|
||||
`int pm_runtime_put_sync_autosuspend(struct device *dev);`
|
||||
- decrement the device's usage counter; if the result is 0 then run
|
||||
- set the power.last_busy field to the current time and decrement the
|
||||
device's usage counter; if the result is 0 then run
|
||||
pm_runtime_autosuspend(dev) and return its result
|
||||
|
||||
`void pm_runtime_enable(struct device *dev);`
|
||||
|
|
@ -870,11 +869,9 @@ device is automatically suspended (the subsystem or driver still has to call
|
|||
the appropriate PM routines); rather it means that runtime suspends will
|
||||
automatically be delayed until the desired period of inactivity has elapsed.
|
||||
|
||||
Inactivity is determined based on the power.last_busy field. Drivers should
|
||||
call pm_runtime_mark_last_busy() to update this field after carrying out I/O,
|
||||
typically just before calling __pm_runtime_put_autosuspend(). The desired
|
||||
length of the inactivity period is a matter of policy. Subsystems can set this
|
||||
length initially by calling pm_runtime_set_autosuspend_delay(), but after device
|
||||
Inactivity is determined based on the power.last_busy field. The desired length
|
||||
of the inactivity period is a matter of policy. Subsystems can set this length
|
||||
initially by calling pm_runtime_set_autosuspend_delay(), but after device
|
||||
registration the length should be controlled by user space, using the
|
||||
/sys/devices/.../power/autosuspend_delay_ms attribute.
|
||||
|
||||
|
|
@ -885,12 +882,13 @@ instead of the non-autosuspend counterparts::
|
|||
|
||||
Instead of: pm_runtime_suspend use: pm_runtime_autosuspend;
|
||||
Instead of: pm_schedule_suspend use: pm_request_autosuspend;
|
||||
Instead of: pm_runtime_put use: __pm_runtime_put_autosuspend;
|
||||
Instead of: pm_runtime_put use: pm_runtime_put_autosuspend;
|
||||
Instead of: pm_runtime_put_sync use: pm_runtime_put_sync_autosuspend.
|
||||
|
||||
Drivers may also continue to use the non-autosuspend helper functions; they
|
||||
will behave normally, which means sometimes taking the autosuspend delay into
|
||||
account (see pm_runtime_idle).
|
||||
account (see pm_runtime_idle). The autosuspend variants of the functions also
|
||||
call pm_runtime_mark_last_busy().
|
||||
|
||||
Under some circumstances a driver or subsystem may want to prevent a device
|
||||
from autosuspending immediately, even though the usage counter is zero and the
|
||||
|
|
@ -922,12 +920,10 @@ Here is a schematic pseudo-code example::
|
|||
foo_io_completion(struct foo_priv *foo, void *req)
|
||||
{
|
||||
lock(&foo->private_lock);
|
||||
if (--foo->num_pending_requests == 0) {
|
||||
pm_runtime_mark_last_busy(&foo->dev);
|
||||
__pm_runtime_put_autosuspend(&foo->dev);
|
||||
} else {
|
||||
if (--foo->num_pending_requests == 0)
|
||||
pm_runtime_put_autosuspend(&foo->dev);
|
||||
else
|
||||
foo_process_next_request(foo);
|
||||
}
|
||||
unlock(&foo->private_lock);
|
||||
/* Send req result back to the user ... */
|
||||
}
|
||||
|
|
|
|||
|
|
@ -267,7 +267,6 @@ static int imx_lpcg_parse_clks_from_dt(struct platform_device *pdev,
|
|||
if (ret)
|
||||
goto unreg;
|
||||
|
||||
pm_runtime_mark_last_busy(&pdev->dev);
|
||||
pm_runtime_put_autosuspend(&pdev->dev);
|
||||
|
||||
return 0;
|
||||
|
|
|
|||
|
|
@ -549,7 +549,6 @@ static int imx_clk_scu_probe(struct platform_device *pdev)
|
|||
|
||||
if (!((clk->rsrc == IMX_SC_R_A35) || (clk->rsrc == IMX_SC_R_A53) ||
|
||||
(clk->rsrc == IMX_SC_R_A72))) {
|
||||
pm_runtime_mark_last_busy(&pdev->dev);
|
||||
pm_runtime_put_autosuspend(&pdev->dev);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -799,7 +799,6 @@ static int lpass_audio_cc_sc7280_probe(struct platform_device *pdev)
|
|||
goto exit;
|
||||
}
|
||||
|
||||
pm_runtime_mark_last_busy(&pdev->dev);
|
||||
exit:
|
||||
pm_runtime_put_autosuspend(&pdev->dev);
|
||||
|
||||
|
|
@ -868,7 +867,6 @@ static int lpass_aon_cc_sc7280_probe(struct platform_device *pdev)
|
|||
goto exit;
|
||||
}
|
||||
|
||||
pm_runtime_mark_last_busy(&pdev->dev);
|
||||
exit:
|
||||
pm_runtime_put_autosuspend(&pdev->dev);
|
||||
|
||||
|
|
|
|||
|
|
@ -412,7 +412,6 @@ static int lpass_core_cc_sc7180_probe(struct platform_device *pdev)
|
|||
|
||||
ret = qcom_cc_really_probe(&pdev->dev, &lpass_core_cc_sc7180_desc, regmap);
|
||||
|
||||
pm_runtime_mark_last_busy(&pdev->dev);
|
||||
exit:
|
||||
pm_runtime_put_autosuspend(&pdev->dev);
|
||||
|
||||
|
|
@ -433,7 +432,6 @@ static int lpass_hm_core_probe(struct platform_device *pdev)
|
|||
|
||||
ret = qcom_cc_probe_by_index(pdev, 0, desc);
|
||||
|
||||
pm_runtime_mark_last_busy(&pdev->dev);
|
||||
pm_runtime_put_autosuspend(&pdev->dev);
|
||||
|
||||
return ret;
|
||||
|
|
|
|||
|
|
@ -337,6 +337,20 @@ static inline void pm_runtime_release_supplier(struct device_link *link) {}
|
|||
* Invoke the "idle check" callback of @dev and, depending on its return value,
|
||||
* set up autosuspend of @dev or suspend it (depending on whether or not
|
||||
* autosuspend has been enabled for it).
|
||||
*
|
||||
* Return:
|
||||
* * 0: Success.
|
||||
* * -EINVAL: Runtime PM error.
|
||||
* * -EACCES: Runtime PM disabled.
|
||||
* * -EAGAIN: Runtime PM usage_count non-zero, Runtime PM status change ongoing
|
||||
* or device not in %RPM_ACTIVE state.
|
||||
* * -EBUSY: Runtime PM child_count non-zero.
|
||||
* * -EPERM: Device PM QoS resume latency 0.
|
||||
* * -EINPROGRESS: Suspend already in progress.
|
||||
* * -ENOSYS: CONFIG_PM not enabled.
|
||||
* * 1: Device already suspended.
|
||||
* Other values and conditions for the above values are possible as returned by
|
||||
* Runtime PM idle and suspend callbacks.
|
||||
*/
|
||||
static inline int pm_runtime_idle(struct device *dev)
|
||||
{
|
||||
|
|
@ -346,6 +360,18 @@ static inline int pm_runtime_idle(struct device *dev)
|
|||
/**
|
||||
* pm_runtime_suspend - Suspend a device synchronously.
|
||||
* @dev: Target device.
|
||||
*
|
||||
* Return:
|
||||
* * 0: Success.
|
||||
* * -EINVAL: Runtime PM error.
|
||||
* * -EACCES: Runtime PM disabled.
|
||||
* * -EAGAIN: Runtime PM usage_count non-zero or Runtime PM status change ongoing.
|
||||
* * -EBUSY: Runtime PM child_count non-zero.
|
||||
* * -EPERM: Device PM QoS resume latency 0.
|
||||
* * -ENOSYS: CONFIG_PM not enabled.
|
||||
* * 1: Device already suspended.
|
||||
* Other values and conditions for the above values are possible as returned by
|
||||
* Runtime PM suspend callbacks.
|
||||
*/
|
||||
static inline int pm_runtime_suspend(struct device *dev)
|
||||
{
|
||||
|
|
@ -353,14 +379,29 @@ static inline int pm_runtime_suspend(struct device *dev)
|
|||
}
|
||||
|
||||
/**
|
||||
* pm_runtime_autosuspend - Set up autosuspend of a device or suspend it.
|
||||
* pm_runtime_autosuspend - Update the last access time and set up autosuspend
|
||||
* of a device.
|
||||
* @dev: Target device.
|
||||
*
|
||||
* Set up autosuspend of @dev or suspend it (depending on whether or not
|
||||
* autosuspend is enabled for it) without engaging its "idle check" callback.
|
||||
* First update the last access time, then set up autosuspend of @dev or suspend
|
||||
* it (depending on whether or not autosuspend is enabled for it) without
|
||||
* engaging its "idle check" callback.
|
||||
*
|
||||
* Return:
|
||||
* * 0: Success.
|
||||
* * -EINVAL: Runtime PM error.
|
||||
* * -EACCES: Runtime PM disabled.
|
||||
* * -EAGAIN: Runtime PM usage_count non-zero or Runtime PM status change ongoing.
|
||||
* * -EBUSY: Runtime PM child_count non-zero.
|
||||
* * -EPERM: Device PM QoS resume latency 0.
|
||||
* * -ENOSYS: CONFIG_PM not enabled.
|
||||
* * 1: Device already suspended.
|
||||
* Other values and conditions for the above values are possible as returned by
|
||||
* Runtime PM suspend callbacks.
|
||||
*/
|
||||
static inline int pm_runtime_autosuspend(struct device *dev)
|
||||
{
|
||||
pm_runtime_mark_last_busy(dev);
|
||||
return __pm_runtime_suspend(dev, RPM_AUTO);
|
||||
}
|
||||
|
||||
|
|
@ -379,6 +420,18 @@ static inline int pm_runtime_resume(struct device *dev)
|
|||
*
|
||||
* Queue up a work item to run an equivalent of pm_runtime_idle() for @dev
|
||||
* asynchronously.
|
||||
*
|
||||
* Return:
|
||||
* * 0: Success.
|
||||
* * -EINVAL: Runtime PM error.
|
||||
* * -EACCES: Runtime PM disabled.
|
||||
* * -EAGAIN: Runtime PM usage_count non-zero, Runtime PM status change ongoing
|
||||
* or device not in %RPM_ACTIVE state.
|
||||
* * -EBUSY: Runtime PM child_count non-zero.
|
||||
* * -EPERM: Device PM QoS resume latency 0.
|
||||
* * -EINPROGRESS: Suspend already in progress.
|
||||
* * -ENOSYS: CONFIG_PM not enabled.
|
||||
* * 1: Device already suspended.
|
||||
*/
|
||||
static inline int pm_request_idle(struct device *dev)
|
||||
{
|
||||
|
|
@ -395,14 +448,27 @@ static inline int pm_request_resume(struct device *dev)
|
|||
}
|
||||
|
||||
/**
|
||||
* pm_request_autosuspend - Queue up autosuspend of a device.
|
||||
* pm_request_autosuspend - Update the last access time and queue up autosuspend
|
||||
* of a device.
|
||||
* @dev: Target device.
|
||||
*
|
||||
* Queue up a work item to run an equivalent pm_runtime_autosuspend() for @dev
|
||||
* asynchronously.
|
||||
* Update the last access time of a device and queue up a work item to run an
|
||||
* equivalent pm_runtime_autosuspend() for @dev asynchronously.
|
||||
*
|
||||
* Return:
|
||||
* * 0: Success.
|
||||
* * -EINVAL: Runtime PM error.
|
||||
* * -EACCES: Runtime PM disabled.
|
||||
* * -EAGAIN: Runtime PM usage_count non-zero or Runtime PM status change ongoing.
|
||||
* * -EBUSY: Runtime PM child_count non-zero.
|
||||
* * -EPERM: Device PM QoS resume latency 0.
|
||||
* * -EINPROGRESS: Suspend already in progress.
|
||||
* * -ENOSYS: CONFIG_PM not enabled.
|
||||
* * 1: Device already suspended.
|
||||
*/
|
||||
static inline int pm_request_autosuspend(struct device *dev)
|
||||
{
|
||||
pm_runtime_mark_last_busy(dev);
|
||||
return __pm_runtime_suspend(dev, RPM_ASYNC | RPM_AUTO);
|
||||
}
|
||||
|
||||
|
|
@ -464,6 +530,17 @@ static inline int pm_runtime_resume_and_get(struct device *dev)
|
|||
*
|
||||
* Decrement the runtime PM usage counter of @dev and if it turns out to be
|
||||
* equal to 0, queue up a work item for @dev like in pm_request_idle().
|
||||
*
|
||||
* Return:
|
||||
* * 0: Success.
|
||||
* * -EINVAL: Runtime PM error.
|
||||
* * -EACCES: Runtime PM disabled.
|
||||
* * -EAGAIN: Runtime PM usage_count non-zero or Runtime PM status change ongoing.
|
||||
* * -EBUSY: Runtime PM child_count non-zero.
|
||||
* * -EPERM: Device PM QoS resume latency 0.
|
||||
* * -EINPROGRESS: Suspend already in progress.
|
||||
* * -ENOSYS: CONFIG_PM not enabled.
|
||||
* * 1: Device already suspended.
|
||||
*/
|
||||
static inline int pm_runtime_put(struct device *dev)
|
||||
{
|
||||
|
|
@ -478,6 +555,17 @@ DEFINE_FREE(pm_runtime_put, struct device *, if (_T) pm_runtime_put(_T))
|
|||
*
|
||||
* Decrement the runtime PM usage counter of @dev and if it turns out to be
|
||||
* equal to 0, queue up a work item for @dev like in pm_request_autosuspend().
|
||||
*
|
||||
* Return:
|
||||
* * 0: Success.
|
||||
* * -EINVAL: Runtime PM error.
|
||||
* * -EACCES: Runtime PM disabled.
|
||||
* * -EAGAIN: Runtime PM usage_count non-zero or Runtime PM status change ongoing.
|
||||
* * -EBUSY: Runtime PM child_count non-zero.
|
||||
* * -EPERM: Device PM QoS resume latency 0.
|
||||
* * -EINPROGRESS: Suspend already in progress.
|
||||
* * -ENOSYS: CONFIG_PM not enabled.
|
||||
* * 1: Device already suspended.
|
||||
*/
|
||||
static inline int __pm_runtime_put_autosuspend(struct device *dev)
|
||||
{
|
||||
|
|
@ -485,16 +573,29 @@ static inline int __pm_runtime_put_autosuspend(struct device *dev)
|
|||
}
|
||||
|
||||
/**
|
||||
* pm_runtime_put_autosuspend - Drop device usage counter and queue autosuspend if 0.
|
||||
* pm_runtime_put_autosuspend - Update the last access time of a device, drop
|
||||
* its usage counter and queue autosuspend if the usage counter becomes 0.
|
||||
* @dev: Target device.
|
||||
*
|
||||
* Decrement the runtime PM usage counter of @dev and if it turns out to be
|
||||
* equal to 0, queue up a work item for @dev like in pm_request_autosuspend().
|
||||
* Update the last access time of @dev, decrement runtime PM usage counter of
|
||||
* @dev and if it turns out to be equal to 0, queue up a work item for @dev like
|
||||
* in pm_request_autosuspend().
|
||||
*
|
||||
* Return:
|
||||
* * 0: Success.
|
||||
* * -EINVAL: Runtime PM error.
|
||||
* * -EACCES: Runtime PM disabled.
|
||||
* * -EAGAIN: Runtime PM usage_count non-zero or Runtime PM status change ongoing.
|
||||
* * -EBUSY: Runtime PM child_count non-zero.
|
||||
* * -EPERM: Device PM QoS resume latency 0.
|
||||
* * -EINPROGRESS: Suspend already in progress.
|
||||
* * -ENOSYS: CONFIG_PM not enabled.
|
||||
* * 1: Device already suspended.
|
||||
*/
|
||||
static inline int pm_runtime_put_autosuspend(struct device *dev)
|
||||
{
|
||||
return __pm_runtime_suspend(dev,
|
||||
RPM_GET_PUT | RPM_ASYNC | RPM_AUTO);
|
||||
pm_runtime_mark_last_busy(dev);
|
||||
return __pm_runtime_put_autosuspend(dev);
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -506,9 +607,20 @@ static inline int pm_runtime_put_autosuspend(struct device *dev)
|
|||
* return value, set up autosuspend of @dev or suspend it (depending on whether
|
||||
* or not autosuspend has been enabled for it).
|
||||
*
|
||||
* The possible return values of this function are the same as for
|
||||
* pm_runtime_idle() and the runtime PM usage counter of @dev remains
|
||||
* decremented in all cases, even if it returns an error code.
|
||||
* The runtime PM usage counter of @dev remains decremented in all cases, even
|
||||
* if it returns an error code.
|
||||
*
|
||||
* Return:
|
||||
* * 0: Success.
|
||||
* * -EINVAL: Runtime PM error.
|
||||
* * -EACCES: Runtime PM disabled.
|
||||
* * -EAGAIN: Runtime PM usage_count non-zero or Runtime PM status change ongoing.
|
||||
* * -EBUSY: Runtime PM child_count non-zero.
|
||||
* * -EPERM: Device PM QoS resume latency 0.
|
||||
* * -ENOSYS: CONFIG_PM not enabled.
|
||||
* * 1: Device already suspended.
|
||||
* Other values and conditions for the above values are possible as returned by
|
||||
* Runtime PM suspend callbacks.
|
||||
*/
|
||||
static inline int pm_runtime_put_sync(struct device *dev)
|
||||
{
|
||||
|
|
@ -522,9 +634,21 @@ static inline int pm_runtime_put_sync(struct device *dev)
|
|||
* Decrement the runtime PM usage counter of @dev and if it turns out to be
|
||||
* equal to 0, carry out runtime-suspend of @dev synchronously.
|
||||
*
|
||||
* The possible return values of this function are the same as for
|
||||
* pm_runtime_suspend() and the runtime PM usage counter of @dev remains
|
||||
* decremented in all cases, even if it returns an error code.
|
||||
* The runtime PM usage counter of @dev remains decremented in all cases, even
|
||||
* if it returns an error code.
|
||||
*
|
||||
* Return:
|
||||
* * 0: Success.
|
||||
* * -EINVAL: Runtime PM error.
|
||||
* * -EACCES: Runtime PM disabled.
|
||||
* * -EAGAIN: Runtime PM usage_count non-zero or Runtime PM status change ongoing.
|
||||
* * -EAGAIN: usage_count non-zero or Runtime PM status change ongoing.
|
||||
* * -EBUSY: Runtime PM child_count non-zero.
|
||||
* * -EPERM: Device PM QoS resume latency 0.
|
||||
* * -ENOSYS: CONFIG_PM not enabled.
|
||||
* * 1: Device already suspended.
|
||||
* Other values and conditions for the above values are possible as returned by
|
||||
* Runtime PM suspend callbacks.
|
||||
*/
|
||||
static inline int pm_runtime_put_sync_suspend(struct device *dev)
|
||||
{
|
||||
|
|
@ -532,19 +656,34 @@ static inline int pm_runtime_put_sync_suspend(struct device *dev)
|
|||
}
|
||||
|
||||
/**
|
||||
* pm_runtime_put_sync_autosuspend - Drop device usage counter and autosuspend if 0.
|
||||
* pm_runtime_put_sync_autosuspend - Update the last access time of a device,
|
||||
* drop device usage counter and autosuspend if 0.
|
||||
* @dev: Target device.
|
||||
*
|
||||
* Decrement the runtime PM usage counter of @dev and if it turns out to be
|
||||
* equal to 0, set up autosuspend of @dev or suspend it synchronously (depending
|
||||
* on whether or not autosuspend has been enabled for it).
|
||||
* Update the last access time of @dev, decrement the runtime PM usage counter
|
||||
* of @dev and if it turns out to be equal to 0, set up autosuspend of @dev or
|
||||
* suspend it synchronously (depending on whether or not autosuspend has been
|
||||
* enabled for it).
|
||||
*
|
||||
* The possible return values of this function are the same as for
|
||||
* pm_runtime_autosuspend() and the runtime PM usage counter of @dev remains
|
||||
* decremented in all cases, even if it returns an error code.
|
||||
* The runtime PM usage counter of @dev remains decremented in all cases, even
|
||||
* if it returns an error code.
|
||||
*
|
||||
* Return:
|
||||
* * 0: Success.
|
||||
* * -EINVAL: Runtime PM error.
|
||||
* * -EACCES: Runtime PM disabled.
|
||||
* * -EAGAIN: Runtime PM usage_count non-zero or Runtime PM status change ongoing.
|
||||
* * -EBUSY: Runtime PM child_count non-zero.
|
||||
* * -EPERM: Device PM QoS resume latency 0.
|
||||
* * -EINPROGRESS: Suspend already in progress.
|
||||
* * -ENOSYS: CONFIG_PM not enabled.
|
||||
* * 1: Device already suspended.
|
||||
* Other values and conditions for the above values are possible as returned by
|
||||
* Runtime PM suspend callbacks.
|
||||
*/
|
||||
static inline int pm_runtime_put_sync_autosuspend(struct device *dev)
|
||||
{
|
||||
pm_runtime_mark_last_busy(dev);
|
||||
return __pm_runtime_suspend(dev, RPM_GET_PUT | RPM_AUTO);
|
||||
}
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue