Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/rafael/suspend-2.6
* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/rafael/suspend-2.6: (51 commits) PM: Improve error code of pm_notifier_call_chain() PM: Add "RTC" to PM trace time stamps to avoid confusion PM / Suspend: Export suspend_set_ops, suspend_valid_only_mem PM / Suspend: Add .suspend_again() callback to suspend_ops PM / OPP: Introduce function to free cpufreq table ARM / shmobile: Return -EBUSY from A4LC power off if A3RV is active PM / Domains: Take .power_off() error code into account ARM / shmobile: Use genpd_queue_power_off_work() ARM / shmobile: Use pm_genpd_poweroff_unused() PM / Domains: Introduce function to power off all unused PM domains OMAP: PM: disable idle on suspend for GPIO and UART OMAP: PM: omap_device: add API to disable idle on suspend OMAP: PM: omap_device: add system PM methods for PM domain handling OMAP: PM: omap_device: conditionally use PM domain runtime helpers PM / Runtime: Add new helper function: pm_runtime_status_suspended() PM / Domains: Queue up power off work only if it is not pending PM / Domains: Improve handling of wakeup devices during system suspend PM / Domains: Do not restore all devices on power off error PM / Domains: Allow callbacks to execute all runtime PM helpers PM / Domains: Do not execute device callbacks under locks ...
This commit is contained in:
commit
431bf99d26
|
@ -506,8 +506,8 @@ routines. Nevertheless, different callback pointers are used in case there is a
|
|||
situation where it actually matters.
|
||||
|
||||
|
||||
Device Power Domains
|
||||
--------------------
|
||||
Device Power Management Domains
|
||||
-------------------------------
|
||||
Sometimes devices share reference clocks or other power resources. In those
|
||||
cases it generally is not possible to put devices into low-power states
|
||||
individually. Instead, a set of devices sharing a power resource can be put
|
||||
|
@ -516,8 +516,8 @@ power resource. Of course, they also need to be put into the full-power state
|
|||
together, by turning the shared power resource on. A set of devices with this
|
||||
property is often referred to as a power domain.
|
||||
|
||||
Support for power domains is provided through the pwr_domain field of struct
|
||||
device. This field is a pointer to an object of type struct dev_power_domain,
|
||||
Support for power domains is provided through the pm_domain field of struct
|
||||
device. This field is a pointer to an object of type struct dev_pm_domain,
|
||||
defined in include/linux/pm.h, providing a set of power management callbacks
|
||||
analogous to the subsystem-level and device driver callbacks that are executed
|
||||
for the given device during all power transitions, instead of the respective
|
||||
|
@ -604,7 +604,7 @@ state temporarily, for example so that its system wakeup capability can be
|
|||
disabled. This all depends on the hardware and the design of the subsystem and
|
||||
device driver in question.
|
||||
|
||||
During system-wide resume from a sleep state it's best to put devices into the
|
||||
full-power state, as explained in Documentation/power/runtime_pm.txt. Refer to
|
||||
that document for more information regarding this particular issue as well as
|
||||
During system-wide resume from a sleep state it's easiest to put devices into
|
||||
the full-power state, as explained in Documentation/power/runtime_pm.txt. Refer
|
||||
to that document for more information regarding this particular issue as well as
|
||||
for information on the device runtime power management framework in general.
|
||||
|
|
|
@ -321,6 +321,8 @@ opp_init_cpufreq_table - cpufreq framework typically is initialized with
|
|||
addition to CONFIG_PM as power management feature is required to
|
||||
dynamically scale voltage and frequency in a system.
|
||||
|
||||
opp_free_cpufreq_table - Free up the table allocated by opp_init_cpufreq_table
|
||||
|
||||
7. Data Structures
|
||||
==================
|
||||
Typically an SoC contains multiple voltage domains which are variable. Each
|
||||
|
|
|
@ -1,39 +1,39 @@
|
|||
Run-time Power Management Framework for I/O Devices
|
||||
Runtime Power Management Framework for I/O Devices
|
||||
|
||||
(C) 2009-2011 Rafael J. Wysocki <rjw@sisk.pl>, Novell Inc.
|
||||
(C) 2010 Alan Stern <stern@rowland.harvard.edu>
|
||||
|
||||
1. Introduction
|
||||
|
||||
Support for run-time power management (run-time PM) of I/O devices is provided
|
||||
Support for runtime power management (runtime PM) of I/O devices is provided
|
||||
at the power management core (PM core) level by means of:
|
||||
|
||||
* The power management workqueue pm_wq in which bus types and device drivers can
|
||||
put their PM-related work items. It is strongly recommended that pm_wq be
|
||||
used for queuing all work items related to run-time PM, because this allows
|
||||
used for queuing all work items related to runtime PM, because this allows
|
||||
them to be synchronized with system-wide power transitions (suspend to RAM,
|
||||
hibernation and resume from system sleep states). pm_wq is declared in
|
||||
include/linux/pm_runtime.h and defined in kernel/power/main.c.
|
||||
|
||||
* A number of run-time PM fields in the 'power' member of 'struct device' (which
|
||||
* A number of runtime PM fields in the 'power' member of 'struct device' (which
|
||||
is of the type 'struct dev_pm_info', defined in include/linux/pm.h) that can
|
||||
be used for synchronizing run-time PM operations with one another.
|
||||
be used for synchronizing runtime PM operations with one another.
|
||||
|
||||
* Three device run-time PM callbacks in 'struct dev_pm_ops' (defined in
|
||||
* Three device runtime PM callbacks in 'struct dev_pm_ops' (defined in
|
||||
include/linux/pm.h).
|
||||
|
||||
* A set of helper functions defined in drivers/base/power/runtime.c that can be
|
||||
used for carrying out run-time PM operations in such a way that the
|
||||
used for carrying out runtime PM operations in such a way that the
|
||||
synchronization between them is taken care of by the PM core. Bus types and
|
||||
device drivers are encouraged to use these functions.
|
||||
|
||||
The run-time PM callbacks present in 'struct dev_pm_ops', the device run-time PM
|
||||
The runtime PM callbacks present in 'struct dev_pm_ops', the device runtime PM
|
||||
fields of 'struct dev_pm_info' and the core helper functions provided for
|
||||
run-time PM are described below.
|
||||
runtime PM are described below.
|
||||
|
||||
2. Device Run-time PM Callbacks
|
||||
2. Device Runtime PM Callbacks
|
||||
|
||||
There are three device run-time PM callbacks defined in 'struct dev_pm_ops':
|
||||
There are three device runtime PM callbacks defined in 'struct dev_pm_ops':
|
||||
|
||||
struct dev_pm_ops {
|
||||
...
|
||||
|
@ -72,11 +72,11 @@ knows what to do to handle the device).
|
|||
not mean that the device has been put into a low power state. It is
|
||||
supposed to mean, however, that the device will not process data and will
|
||||
not communicate with the CPU(s) and RAM until the subsystem-level resume
|
||||
callback is executed for it. The run-time PM status of a device after
|
||||
callback is executed for it. The runtime PM status of a device after
|
||||
successful execution of the subsystem-level suspend callback is 'suspended'.
|
||||
|
||||
* If the subsystem-level suspend callback returns -EBUSY or -EAGAIN,
|
||||
the device's run-time PM status is 'active', which means that the device
|
||||
the device's runtime PM status is 'active', which means that the device
|
||||
_must_ be fully operational afterwards.
|
||||
|
||||
* If the subsystem-level suspend callback returns an error code different
|
||||
|
@ -104,7 +104,7 @@ the device).
|
|||
|
||||
* Once the subsystem-level resume callback has completed successfully, the PM
|
||||
core regards the device as fully operational, which means that the device
|
||||
_must_ be able to complete I/O operations as needed. The run-time PM status
|
||||
_must_ be able to complete I/O operations as needed. The runtime PM status
|
||||
of the device is then 'active'.
|
||||
|
||||
* If the subsystem-level resume callback returns an error code, the PM core
|
||||
|
@ -130,7 +130,7 @@ device in that case. The value returned by this callback is 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 the bus type's run-time
|
||||
that the following constraints are met with respect to the bus type's runtime
|
||||
PM callbacks:
|
||||
|
||||
(1) The callbacks are mutually exclusive (e.g. it is forbidden to execute
|
||||
|
@ -142,7 +142,7 @@ PM callbacks:
|
|||
|
||||
(2) ->runtime_idle() and ->runtime_suspend() can only be executed for 'active'
|
||||
devices (i.e. the PM core will only execute ->runtime_idle() or
|
||||
->runtime_suspend() for the devices the run-time PM status of which is
|
||||
->runtime_suspend() for the devices the runtime PM status of which is
|
||||
'active').
|
||||
|
||||
(3) ->runtime_idle() and ->runtime_suspend() can only be executed for a device
|
||||
|
@ -151,7 +151,7 @@ PM callbacks:
|
|||
flag of which is set.
|
||||
|
||||
(4) ->runtime_resume() can only be executed for 'suspended' devices (i.e. the
|
||||
PM core will only execute ->runtime_resume() for the devices the run-time
|
||||
PM core will only execute ->runtime_resume() for the devices the runtime
|
||||
PM status of which is 'suspended').
|
||||
|
||||
Additionally, the helper functions provided by the PM core obey the following
|
||||
|
@ -171,9 +171,9 @@ rules:
|
|||
scheduled requests to execute the other callbacks for the same device,
|
||||
except for scheduled autosuspends.
|
||||
|
||||
3. Run-time PM Device Fields
|
||||
3. Runtime PM Device Fields
|
||||
|
||||
The following device run-time PM fields are present in 'struct dev_pm_info', as
|
||||
The following device runtime PM fields are present in 'struct dev_pm_info', as
|
||||
defined in include/linux/pm.h:
|
||||
|
||||
struct timer_list suspend_timer;
|
||||
|
@ -205,7 +205,7 @@ defined in include/linux/pm.h:
|
|||
|
||||
unsigned int disable_depth;
|
||||
- used for disabling the helper funcions (they work normally if this is
|
||||
equal to zero); the initial value of it is 1 (i.e. run-time PM is
|
||||
equal to zero); the initial value of it is 1 (i.e. runtime PM is
|
||||
initially disabled for all devices)
|
||||
|
||||
unsigned int runtime_error;
|
||||
|
@ -229,10 +229,10 @@ defined in include/linux/pm.h:
|
|||
suspend to complete; means "start a resume as soon as you've suspended"
|
||||
|
||||
unsigned int run_wake;
|
||||
- set if the device is capable of generating run-time wake-up events
|
||||
- set if the device is capable of generating runtime wake-up events
|
||||
|
||||
enum rpm_status runtime_status;
|
||||
- the run-time PM status of the device; this field's initial value is
|
||||
- the runtime PM status of the device; this field's initial value is
|
||||
RPM_SUSPENDED, which means that each device is initially regarded by the
|
||||
PM core as 'suspended', regardless of its real hardware status
|
||||
|
||||
|
@ -243,7 +243,7 @@ defined in include/linux/pm.h:
|
|||
and pm_runtime_forbid() helper functions
|
||||
|
||||
unsigned int no_callbacks;
|
||||
- indicates that the device does not use the run-time PM callbacks (see
|
||||
- indicates that the device does not use the runtime PM callbacks (see
|
||||
Section 8); it may be modified only by the pm_runtime_no_callbacks()
|
||||
helper function
|
||||
|
||||
|
@ -270,16 +270,16 @@ defined in include/linux/pm.h:
|
|||
|
||||
All of the above fields are members of the 'power' member of 'struct device'.
|
||||
|
||||
4. Run-time PM Device Helper Functions
|
||||
4. Runtime PM Device Helper Functions
|
||||
|
||||
The following run-time PM helper functions are defined in
|
||||
The following runtime PM helper functions are defined in
|
||||
drivers/base/power/runtime.c and include/linux/pm_runtime.h:
|
||||
|
||||
void pm_runtime_init(struct device *dev);
|
||||
- initialize the device run-time PM fields in 'struct dev_pm_info'
|
||||
- initialize the device runtime PM fields in 'struct dev_pm_info'
|
||||
|
||||
void pm_runtime_remove(struct device *dev);
|
||||
- make sure that the run-time PM of the device will be disabled after
|
||||
- make sure that the runtime PM of the device will be disabled after
|
||||
removing the device from device hierarchy
|
||||
|
||||
int pm_runtime_idle(struct device *dev);
|
||||
|
@ -289,9 +289,10 @@ drivers/base/power/runtime.c and include/linux/pm_runtime.h:
|
|||
|
||||
int pm_runtime_suspend(struct device *dev);
|
||||
- execute the subsystem-level suspend callback for the device; returns 0 on
|
||||
success, 1 if the device's run-time PM status was already 'suspended', or
|
||||
success, 1 if the device's runtime PM status was already 'suspended', or
|
||||
error code on failure, where -EAGAIN or -EBUSY means it is safe to attempt
|
||||
to suspend the device again in future
|
||||
to suspend the device again in future and -EACCES means that
|
||||
'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
|
||||
|
@ -301,10 +302,11 @@ drivers/base/power/runtime.c and include/linux/pm_runtime.h:
|
|||
|
||||
int pm_runtime_resume(struct device *dev);
|
||||
- execute the subsystem-level resume callback for the device; returns 0 on
|
||||
success, 1 if the device's run-time PM status was already 'active' or
|
||||
success, 1 if the device's runtime PM status was already 'active' or
|
||||
error code on failure, where -EAGAIN means it may be safe to attempt to
|
||||
resume the device again in future, but 'power.runtime_error' should be
|
||||
checked additionally
|
||||
checked additionally, and -EACCES means that 'power.disable_depth' is
|
||||
different from 0
|
||||
|
||||
int pm_request_idle(struct device *dev);
|
||||
- submit a request to execute the subsystem-level idle callback for the
|
||||
|
@ -321,7 +323,7 @@ drivers/base/power/runtime.c and include/linux/pm_runtime.h:
|
|||
device in future, where 'delay' is the time to wait before queuing up a
|
||||
suspend work item in pm_wq, in milliseconds (if 'delay' is zero, the work
|
||||
item is queued up immediately); returns 0 on success, 1 if the device's PM
|
||||
run-time status was already 'suspended', or error code if the request
|
||||
runtime status was already 'suspended', or error code if the request
|
||||
hasn't been scheduled (or queued up if 'delay' is 0); if the execution of
|
||||
->runtime_suspend() is already scheduled and not yet expired, the new
|
||||
value of 'delay' will be used as the time to wait
|
||||
|
@ -329,7 +331,7 @@ drivers/base/power/runtime.c and include/linux/pm_runtime.h:
|
|||
int pm_request_resume(struct device *dev);
|
||||
- submit a request to execute the subsystem-level resume callback for the
|
||||
device (the request is represented by a work item in pm_wq); returns 0 on
|
||||
success, 1 if the device's run-time PM status was already 'active', or
|
||||
success, 1 if the device's runtime PM status was already 'active', or
|
||||
error code if the request hasn't been queued up
|
||||
|
||||
void pm_runtime_get_noresume(struct device *dev);
|
||||
|
@ -367,22 +369,32 @@ drivers/base/power/runtime.c and include/linux/pm_runtime.h:
|
|||
pm_runtime_autosuspend(dev) and return its result
|
||||
|
||||
void pm_runtime_enable(struct device *dev);
|
||||
- enable the run-time PM helper functions to run the device bus type's
|
||||
run-time PM callbacks described in Section 2
|
||||
- decrement the device's 'power.disable_depth' field; if that field is equal
|
||||
to zero, the runtime PM helper functions can execute subsystem-level
|
||||
callbacks described in Section 2 for the device
|
||||
|
||||
int pm_runtime_disable(struct device *dev);
|
||||
- prevent the run-time PM helper functions from running subsystem-level
|
||||
run-time PM callbacks for the device, make sure that all of the pending
|
||||
run-time PM operations on the device are either completed or canceled;
|
||||
- increment the device's 'power.disable_depth' field (if the value of that
|
||||
field was previously zero, this prevents subsystem-level runtime PM
|
||||
callbacks from being run for the device), make sure that all of the pending
|
||||
runtime PM operations on the device are either completed or canceled;
|
||||
returns 1 if there was a resume request pending and it was necessary to
|
||||
execute the subsystem-level resume callback for the device to satisfy that
|
||||
request, otherwise 0 is returned
|
||||
|
||||
int pm_runtime_barrier(struct device *dev);
|
||||
- check if there's a resume request pending for the device and resume it
|
||||
(synchronously) in that case, cancel any other pending runtime PM requests
|
||||
regarding it and wait for all runtime PM operations on it in progress to
|
||||
complete; returns 1 if there was a resume request pending and it was
|
||||
necessary to execute the subsystem-level resume callback for the device to
|
||||
satisfy that request, otherwise 0 is returned
|
||||
|
||||
void pm_suspend_ignore_children(struct device *dev, bool enable);
|
||||
- set/unset the power.ignore_children flag of the device
|
||||
|
||||
int pm_runtime_set_active(struct device *dev);
|
||||
- clear the device's 'power.runtime_error' flag, set the device's run-time
|
||||
- clear the device's 'power.runtime_error' flag, set the device's runtime
|
||||
PM status to 'active' and update its parent's counter of 'active'
|
||||
children as appropriate (it is only valid to use this function if
|
||||
'power.runtime_error' is set or 'power.disable_depth' is greater than
|
||||
|
@ -390,7 +402,7 @@ drivers/base/power/runtime.c and include/linux/pm_runtime.h:
|
|||
which is not active and the 'power.ignore_children' flag of which is unset
|
||||
|
||||
void pm_runtime_set_suspended(struct device *dev);
|
||||
- clear the device's 'power.runtime_error' flag, set the device's run-time
|
||||
- clear the device's 'power.runtime_error' flag, set the device's runtime
|
||||
PM status to 'suspended' and update its parent's counter of 'active'
|
||||
children as appropriate (it is only valid to use this function if
|
||||
'power.runtime_error' is set or 'power.disable_depth' is greater than
|
||||
|
@ -400,6 +412,9 @@ drivers/base/power/runtime.c and include/linux/pm_runtime.h:
|
|||
- return true if the device's runtime PM status is 'suspended' and its
|
||||
'power.disable_depth' field is equal to zero, or false otherwise
|
||||
|
||||
bool pm_runtime_status_suspended(struct device *dev);
|
||||
- return true if the device's runtime PM status is 'suspended'
|
||||
|
||||
void pm_runtime_allow(struct device *dev);
|
||||
- set the power.runtime_auto flag for the device and decrease its usage
|
||||
counter (used by the /sys/devices/.../power/control interface to
|
||||
|
@ -411,7 +426,7 @@ drivers/base/power/runtime.c and include/linux/pm_runtime.h:
|
|||
effectively prevent the device from being power managed at run time)
|
||||
|
||||
void pm_runtime_no_callbacks(struct device *dev);
|
||||
- set the power.no_callbacks flag for the device and remove the run-time
|
||||
- set the power.no_callbacks flag for the device and remove the runtime
|
||||
PM attributes from /sys/devices/.../power (or prevent them from being
|
||||
added when the device is registered)
|
||||
|
||||
|
@ -431,7 +446,7 @@ drivers/base/power/runtime.c and include/linux/pm_runtime.h:
|
|||
|
||||
void pm_runtime_set_autosuspend_delay(struct device *dev, int delay);
|
||||
- set the power.autosuspend_delay value to 'delay' (expressed in
|
||||
milliseconds); if 'delay' is negative then run-time suspends are
|
||||
milliseconds); if 'delay' is negative then runtime suspends are
|
||||
prevented
|
||||
|
||||
unsigned long pm_runtime_autosuspend_expiration(struct device *dev);
|
||||
|
@ -470,35 +485,35 @@ pm_runtime_resume()
|
|||
pm_runtime_get_sync()
|
||||
pm_runtime_put_sync_suspend()
|
||||
|
||||
5. Run-time PM Initialization, Device Probing and Removal
|
||||
5. Runtime PM Initialization, Device Probing and Removal
|
||||
|
||||
Initially, the run-time PM is disabled for all devices, which means that the
|
||||
majority of the run-time PM helper funtions described in Section 4 will return
|
||||
Initially, the runtime PM is disabled for all devices, which means that the
|
||||
majority of the runtime PM helper funtions described in Section 4 will return
|
||||
-EAGAIN until pm_runtime_enable() is called for the device.
|
||||
|
||||
In addition to that, the initial run-time PM status of all devices is
|
||||
In addition to that, the initial runtime PM status of all devices is
|
||||
'suspended', but it need not reflect the actual physical state of the device.
|
||||
Thus, if the device is initially active (i.e. it is able to process I/O), its
|
||||
run-time PM status must be changed to 'active', with the help of
|
||||
runtime PM status must be changed to 'active', with the help of
|
||||
pm_runtime_set_active(), before pm_runtime_enable() is called for the device.
|
||||
|
||||
However, if the device has a parent and the parent's run-time PM is enabled,
|
||||
However, if the device has a parent and the parent's runtime PM is enabled,
|
||||
calling pm_runtime_set_active() for the device will affect the parent, unless
|
||||
the parent's 'power.ignore_children' flag is set. Namely, in that case the
|
||||
parent won't be able to suspend at run time, using the PM core's helper
|
||||
functions, as long as the child's status is 'active', even if the child's
|
||||
run-time PM is still disabled (i.e. pm_runtime_enable() hasn't been called for
|
||||
runtime PM is still disabled (i.e. pm_runtime_enable() hasn't been called for
|
||||
the child yet or pm_runtime_disable() has been called for it). For this reason,
|
||||
once pm_runtime_set_active() has been called for the device, pm_runtime_enable()
|
||||
should be called for it too as soon as reasonably possible or its run-time PM
|
||||
should be called for it too as soon as reasonably possible or its runtime PM
|
||||
status should be changed back to 'suspended' with the help of
|
||||
pm_runtime_set_suspended().
|
||||
|
||||
If the default initial run-time PM status of the device (i.e. 'suspended')
|
||||
If the default initial runtime PM status of the device (i.e. 'suspended')
|
||||
reflects the actual state of the device, its bus type's or its driver's
|
||||
->probe() callback will likely need to wake it up using one of the PM core's
|
||||
helper functions described in Section 4. In that case, pm_runtime_resume()
|
||||
should be used. Of course, for this purpose the device's run-time PM has to be
|
||||
should be used. Of course, for this purpose the device's runtime PM has to be
|
||||
enabled earlier by calling pm_runtime_enable().
|
||||
|
||||
If the device bus type's or driver's ->probe() callback runs
|
||||
|
@ -529,33 +544,33 @@ The user space can effectively disallow the driver of the device to power manage
|
|||
it at run time by changing the value of its /sys/devices/.../power/control
|
||||
attribute to "on", which causes pm_runtime_forbid() to be called. In principle,
|
||||
this mechanism may also be used by the driver to effectively turn off the
|
||||
run-time power management of the device until the user space turns it on.
|
||||
Namely, during the initialization the driver can make sure that the run-time PM
|
||||
runtime power management of the device until the user space turns it on.
|
||||
Namely, during the initialization the driver can make sure that the runtime PM
|
||||
status of the device is 'active' and call pm_runtime_forbid(). It should be
|
||||
noted, however, that if the user space has already intentionally changed the
|
||||
value of /sys/devices/.../power/control to "auto" to allow the driver to power
|
||||
manage the device at run time, the driver may confuse it by using
|
||||
pm_runtime_forbid() this way.
|
||||
|
||||
6. Run-time PM and System Sleep
|
||||
6. Runtime PM and System Sleep
|
||||
|
||||
Run-time PM and system sleep (i.e., system suspend and hibernation, also known
|
||||
Runtime PM and system sleep (i.e., system suspend and hibernation, also known
|
||||
as suspend-to-RAM and suspend-to-disk) interact with each other in a couple of
|
||||
ways. If a device is active when a system sleep starts, everything is
|
||||
straightforward. But what should happen if the device is already suspended?
|
||||
|
||||
The device may have different wake-up settings for run-time PM and system sleep.
|
||||
For example, remote wake-up may be enabled for run-time suspend but disallowed
|
||||
The device may have different wake-up settings for runtime PM and system sleep.
|
||||
For example, remote wake-up may be enabled for runtime suspend but disallowed
|
||||
for system sleep (device_may_wakeup(dev) returns 'false'). When this happens,
|
||||
the subsystem-level system suspend callback is responsible for changing the
|
||||
device's wake-up setting (it may leave that to the device driver's system
|
||||
suspend routine). It may be necessary to resume the device and suspend it again
|
||||
in order to do so. The same is true if the driver uses different power levels
|
||||
or other settings for run-time suspend and system sleep.
|
||||
or other settings for runtime suspend and system sleep.
|
||||
|
||||
During system resume, devices generally should be brought back to full power,
|
||||
even if they were suspended before the system sleep began. There are several
|
||||
reasons for this, including:
|
||||
During system resume, the simplest approach is to bring all devices back to full
|
||||
power, even if they had been suspended before the system suspend began. There
|
||||
are several reasons for this, including:
|
||||
|
||||
* The device might need to switch power levels, wake-up settings, etc.
|
||||
|
||||
|
@ -570,18 +585,50 @@ reasons for this, including:
|
|||
* The device might need to be reset.
|
||||
|
||||
* Even though the device was suspended, if its usage counter was > 0 then most
|
||||
likely it would need a run-time resume in the near future anyway.
|
||||
likely it would need a runtime resume in the near future anyway.
|
||||
|
||||
* Always going back to full power is simplest.
|
||||
|
||||
If the device was suspended before the sleep began, then its run-time PM status
|
||||
will have to be updated to reflect the actual post-system sleep status. The way
|
||||
to do this is:
|
||||
If the device had been suspended before the system suspend began and it's
|
||||
brought back to full power during resume, then its runtime PM status will have
|
||||
to be updated to reflect the actual post-system sleep status. The way to do
|
||||
this is:
|
||||
|
||||
pm_runtime_disable(dev);
|
||||
pm_runtime_set_active(dev);
|
||||
pm_runtime_enable(dev);
|
||||
|
||||
The PM core always increments the runtime usage counter before calling the
|
||||
->suspend() callback and decrements it after calling the ->resume() callback.
|
||||
Hence disabling runtime PM temporarily like this will not cause any runtime
|
||||
suspend attempts to be permanently lost. If the usage count goes to zero
|
||||
following the return of the ->resume() callback, the ->runtime_idle() callback
|
||||
will be invoked as usual.
|
||||
|
||||
On some systems, however, system sleep is not entered through a global firmware
|
||||
or hardware operation. Instead, all hardware components are put into low-power
|
||||
states directly by the kernel in a coordinated way. Then, the system sleep
|
||||
state effectively follows from the states the hardware components end up in
|
||||
and the system is woken up from that state by a hardware interrupt or a similar
|
||||
mechanism entirely under the kernel's control. As a result, the kernel never
|
||||
gives control away and the states of all devices during resume are precisely
|
||||
known to it. If that is the case and none of the situations listed above takes
|
||||
place (in particular, if the system is not waking up from hibernation), it may
|
||||
be more efficient to leave the devices that had been suspended before the system
|
||||
suspend began in the suspended state.
|
||||
|
||||
The PM core does its best to reduce the probability of race conditions between
|
||||
the runtime PM and system suspend/resume (and hibernation) callbacks by carrying
|
||||
out the following operations:
|
||||
|
||||
* During system suspend it calls pm_runtime_get_noresume() and
|
||||
pm_runtime_barrier() for every device right before executing the
|
||||
subsystem-level .suspend() callback for it. In addition to that it calls
|
||||
pm_runtime_disable() for every device right after executing the
|
||||
subsystem-level .suspend() callback for it.
|
||||
|
||||
* During system resume it calls pm_runtime_enable() and pm_runtime_put_sync()
|
||||
for every device right before and right after executing the subsystem-level
|
||||
.resume() callback for it, respectively.
|
||||
|
||||
7. Generic subsystem callbacks
|
||||
|
||||
Subsystems may wish to conserve code space by using the set of generic power
|
||||
|
@ -606,40 +653,68 @@ driver/base/power/generic_ops.c:
|
|||
callback provided by its driver and return its result, or return 0 if not
|
||||
defined
|
||||
|
||||
int pm_generic_suspend_noirq(struct device *dev);
|
||||
- if pm_runtime_suspended(dev) returns "false", invoke the ->suspend_noirq()
|
||||
callback provided by the device's driver and return its result, or return
|
||||
0 if not defined
|
||||
|
||||
int pm_generic_resume(struct device *dev);
|
||||
- invoke the ->resume() callback provided by the driver of this device and,
|
||||
if successful, change the device's runtime PM status to 'active'
|
||||
|
||||
int pm_generic_resume_noirq(struct device *dev);
|
||||
- invoke the ->resume_noirq() callback provided by the driver of this device
|
||||
|
||||
int pm_generic_freeze(struct device *dev);
|
||||
- if the device has not been suspended at run time, invoke the ->freeze()
|
||||
callback provided by its driver and return its result, or return 0 if not
|
||||
defined
|
||||
|
||||
int pm_generic_freeze_noirq(struct device *dev);
|
||||
- if pm_runtime_suspended(dev) returns "false", invoke the ->freeze_noirq()
|
||||
callback provided by the device's driver and return its result, or return
|
||||
0 if not defined
|
||||
|
||||
int pm_generic_thaw(struct device *dev);
|
||||
- if the device has not been suspended at run time, invoke the ->thaw()
|
||||
callback provided by its driver and return its result, or return 0 if not
|
||||
defined
|
||||
|
||||
int pm_generic_thaw_noirq(struct device *dev);
|
||||
- if pm_runtime_suspended(dev) returns "false", invoke the ->thaw_noirq()
|
||||
callback provided by the device's driver and return its result, or return
|
||||
0 if not defined
|
||||
|
||||
int pm_generic_poweroff(struct device *dev);
|
||||
- if the device has not been suspended at run time, invoke the ->poweroff()
|
||||
callback provided by its driver and return its result, or return 0 if not
|
||||
defined
|
||||
|
||||
int pm_generic_poweroff_noirq(struct device *dev);
|
||||
- if pm_runtime_suspended(dev) returns "false", run the ->poweroff_noirq()
|
||||
callback provided by the device's driver and return its result, or return
|
||||
0 if not defined
|
||||
|
||||
int pm_generic_restore(struct device *dev);
|
||||
- invoke the ->restore() callback provided by the driver of this device and,
|
||||
if successful, change the device's runtime PM status to 'active'
|
||||
|
||||
int pm_generic_restore_noirq(struct device *dev);
|
||||
- invoke the ->restore_noirq() callback provided by the device's driver
|
||||
|
||||
These functions can be assigned to the ->runtime_idle(), ->runtime_suspend(),
|
||||
->runtime_resume(), ->suspend(), ->resume(), ->freeze(), ->thaw(), ->poweroff(),
|
||||
or ->restore() callback pointers in the subsystem-level dev_pm_ops structures.
|
||||
->runtime_resume(), ->suspend(), ->suspend_noirq(), ->resume(),
|
||||
->resume_noirq(), ->freeze(), ->freeze_noirq(), ->thaw(), ->thaw_noirq(),
|
||||
->poweroff(), ->poweroff_noirq(), ->restore(), ->restore_noirq() callback
|
||||
pointers in the subsystem-level dev_pm_ops structures.
|
||||
|
||||
If a subsystem wishes to use all of them at the same time, it can simply assign
|
||||
the GENERIC_SUBSYS_PM_OPS macro, defined in include/linux/pm.h, to its
|
||||
dev_pm_ops structure pointer.
|
||||
|
||||
Device drivers that wish to use the same function as a system suspend, freeze,
|
||||
poweroff and run-time suspend callback, and similarly for system resume, thaw,
|
||||
restore, and run-time resume, can achieve this with the help of the
|
||||
poweroff and runtime suspend callback, and similarly for system resume, thaw,
|
||||
restore, and runtime resume, can achieve this with the help of the
|
||||
UNIVERSAL_DEV_PM_OPS macro defined in include/linux/pm.h (possibly setting its
|
||||
last argument to NULL).
|
||||
|
||||
|
@ -649,7 +724,7 @@ Some "devices" are only logical sub-devices of their parent and cannot be
|
|||
power-managed on their own. (The prototype example is a USB interface. Entire
|
||||
USB devices can go into low-power mode or send wake-up requests, but neither is
|
||||
possible for individual interfaces.) The drivers for these devices have no
|
||||
need of run-time PM callbacks; if the callbacks did exist, ->runtime_suspend()
|
||||
need of runtime PM callbacks; if the callbacks did exist, ->runtime_suspend()
|
||||
and ->runtime_resume() would always return 0 without doing anything else and
|
||||
->runtime_idle() would always call pm_runtime_suspend().
|
||||
|
||||
|
@ -657,7 +732,7 @@ Subsystems can tell the PM core about these devices by calling
|
|||
pm_runtime_no_callbacks(). This should be done after the device structure is
|
||||
initialized and before it is registered (although after device registration is
|
||||
also okay). The routine will set the device's power.no_callbacks flag and
|
||||
prevent the non-debugging run-time PM sysfs attributes from being created.
|
||||
prevent the non-debugging runtime PM sysfs attributes from being created.
|
||||
|
||||
When power.no_callbacks is set, the PM core will not invoke the
|
||||
->runtime_idle(), ->runtime_suspend(), or ->runtime_resume() callbacks.
|
||||
|
@ -665,7 +740,7 @@ Instead it will assume that suspends and resumes always succeed and that idle
|
|||
devices should be suspended.
|
||||
|
||||
As a consequence, the PM core will never directly inform the device's subsystem
|
||||
or driver about run-time power changes. Instead, the driver for the device's
|
||||
or driver about runtime power changes. Instead, the driver for the device's
|
||||
parent must take responsibility for telling the device's driver when the
|
||||
parent's power state changes.
|
||||
|
||||
|
@ -676,13 +751,13 @@ A device should be put in a low-power state only when there's some reason to
|
|||
think it will remain in that state for a substantial time. A common heuristic
|
||||
says that a device which hasn't been used for a while is liable to remain
|
||||
unused; following this advice, drivers should not allow devices to be suspended
|
||||
at run-time until they have been inactive for some minimum period. Even when
|
||||
at runtime until they have been inactive for some minimum period. Even when
|
||||
the heuristic ends up being non-optimal, it will still prevent devices from
|
||||
"bouncing" too rapidly between low-power and full-power states.
|
||||
|
||||
The term "autosuspend" is an historical remnant. It doesn't mean that the
|
||||
device is automatically suspended (the subsystem or driver still has to call
|
||||
the appropriate PM routines); rather it means that run-time suspends will
|
||||
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
|
||||
|
|
|
@ -642,6 +642,7 @@ config ARCH_SHMOBILE
|
|||
select NO_IOPORT
|
||||
select SPARSE_IRQ
|
||||
select MULTI_IRQ_HANDLER
|
||||
select PM_GENERIC_DOMAINS if PM
|
||||
help
|
||||
Support for Renesas's SH-Mobile and R-Mobile ARM platforms.
|
||||
|
||||
|
|
|
@ -32,7 +32,7 @@ static int omap1_pm_runtime_suspend(struct device *dev)
|
|||
if (ret)
|
||||
return ret;
|
||||
|
||||
ret = pm_runtime_clk_suspend(dev);
|
||||
ret = pm_clk_suspend(dev);
|
||||
if (ret) {
|
||||
pm_generic_runtime_resume(dev);
|
||||
return ret;
|
||||
|
@ -45,24 +45,24 @@ static int omap1_pm_runtime_resume(struct device *dev)
|
|||
{
|
||||
dev_dbg(dev, "%s\n", __func__);
|
||||
|
||||
pm_runtime_clk_resume(dev);
|
||||
pm_clk_resume(dev);
|
||||
return pm_generic_runtime_resume(dev);
|
||||
}
|
||||
|
||||
static struct dev_power_domain default_power_domain = {
|
||||
static struct dev_pm_domain default_pm_domain = {
|
||||
.ops = {
|
||||
.runtime_suspend = omap1_pm_runtime_suspend,
|
||||
.runtime_resume = omap1_pm_runtime_resume,
|
||||
USE_PLATFORM_PM_SLEEP_OPS
|
||||
},
|
||||
};
|
||||
#define OMAP1_PWR_DOMAIN (&default_power_domain)
|
||||
#define OMAP1_PM_DOMAIN (&default_pm_domain)
|
||||
#else
|
||||
#define OMAP1_PWR_DOMAIN NULL
|
||||
#define OMAP1_PM_DOMAIN NULL
|
||||
#endif /* CONFIG_PM_RUNTIME */
|
||||
|
||||
static struct pm_clk_notifier_block platform_bus_notifier = {
|
||||
.pwr_domain = OMAP1_PWR_DOMAIN,
|
||||
.pm_domain = OMAP1_PM_DOMAIN,
|
||||
.con_ids = { "ick", "fck", NULL, },
|
||||
};
|
||||
|
||||
|
@ -71,7 +71,7 @@ static int __init omap1_pm_runtime_init(void)
|
|||
if (!cpu_class_is_omap1())
|
||||
return -ENODEV;
|
||||
|
||||
pm_runtime_clk_add_notifier(&platform_bus_type, &platform_bus_notifier);
|
||||
pm_clk_add_notifier(&platform_bus_type, &platform_bus_notifier);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
|
@ -119,6 +119,8 @@ static int omap2_gpio_dev_init(struct omap_hwmod *oh, void *unused)
|
|||
return PTR_ERR(od);
|
||||
}
|
||||
|
||||
omap_device_disable_idle_on_suspend(od);
|
||||
|
||||
gpio_bank_count++;
|
||||
return 0;
|
||||
}
|
||||
|
|
|
@ -805,6 +805,7 @@ void __init omap_serial_init_port(struct omap_board_data *bdata)
|
|||
WARN(IS_ERR(od), "Could not build omap_device for %s: %s.\n",
|
||||
name, oh->name);
|
||||
|
||||
omap_device_disable_idle_on_suspend(od);
|
||||
oh->mux = omap_hwmod_mux_init(bdata->pads, bdata->pads_cnt);
|
||||
|
||||
uart->irq = oh->mpu_irqs[0].irq;
|
||||
|
|
|
@ -1408,9 +1408,14 @@ static void __init ap4evb_init(void)
|
|||
|
||||
platform_add_devices(ap4evb_devices, ARRAY_SIZE(ap4evb_devices));
|
||||
|
||||
sh7372_add_device_to_domain(&sh7372_a4lc, &lcdc1_device);
|
||||
sh7372_add_device_to_domain(&sh7372_a4lc, &lcdc_device);
|
||||
sh7372_add_device_to_domain(&sh7372_a4mp, &fsi_device);
|
||||
|
||||
hdmi_init_pm_clock();
|
||||
fsi_init_pm_clock();
|
||||
sh7372_pm_init();
|
||||
pm_clk_add(&fsi_device.dev, "spu2");
|
||||
}
|
||||
|
||||
static void __init ap4evb_timer_init(void)
|
||||
|
|
|
@ -1582,8 +1582,13 @@ static void __init mackerel_init(void)
|
|||
|
||||
platform_add_devices(mackerel_devices, ARRAY_SIZE(mackerel_devices));
|
||||
|
||||
sh7372_add_device_to_domain(&sh7372_a4lc, &lcdc_device);
|
||||
sh7372_add_device_to_domain(&sh7372_a4lc, &hdmi_lcdc_device);
|
||||
sh7372_add_device_to_domain(&sh7372_a4mp, &fsi_device);
|
||||
|
||||
hdmi_init_pm_clock();
|
||||
sh7372_pm_init();
|
||||
pm_clk_add(&fsi_device.dev, "spu2");
|
||||
}
|
||||
|
||||
static void __init mackerel_timer_init(void)
|
||||
|
|
|
@ -662,6 +662,7 @@ static struct clk_lookup lookups[] = {
|
|||
CLKDEV_ICK_ID("ick", "sh-mobile-hdmi", &div6_reparent_clks[DIV6_HDMI]),
|
||||
CLKDEV_ICK_ID("icka", "sh_fsi2", &div6_reparent_clks[DIV6_FSIA]),
|
||||
CLKDEV_ICK_ID("ickb", "sh_fsi2", &div6_reparent_clks[DIV6_FSIB]),
|
||||
CLKDEV_ICK_ID("spu2", "sh_fsi2", &mstp_clks[MSTP223]),
|
||||
};
|
||||
|
||||
void __init sh7372_clock_init(void)
|
||||
|
|
|
@ -12,6 +12,7 @@
|
|||
#define __ASM_SH7372_H__
|
||||
|
||||
#include <linux/sh_clk.h>
|
||||
#include <linux/pm_domain.h>
|
||||
|
||||
/*
|
||||
* Pin Function Controller:
|
||||
|
@ -470,4 +471,32 @@ extern struct clk sh7372_fsibck_clk;
|
|||
extern struct clk sh7372_fsidiva_clk;
|
||||
extern struct clk sh7372_fsidivb_clk;
|
||||
|
||||
struct platform_device;
|
||||
|
||||
struct sh7372_pm_domain {
|
||||
struct generic_pm_domain genpd;
|
||||
unsigned int bit_shift;
|
||||
};
|
||||
|
||||
static inline struct sh7372_pm_domain *to_sh7372_pd(struct generic_pm_domain *d)
|
||||
{
|
||||
return container_of(d, struct sh7372_pm_domain, genpd);
|
||||
}
|
||||
|
||||
#ifdef CONFIG_PM
|
||||
extern struct sh7372_pm_domain sh7372_a4lc;
|
||||
extern struct sh7372_pm_domain sh7372_a4mp;
|
||||
extern struct sh7372_pm_domain sh7372_d4;
|
||||
extern struct sh7372_pm_domain sh7372_a3rv;
|
||||
extern struct sh7372_pm_domain sh7372_a3ri;
|
||||
extern struct sh7372_pm_domain sh7372_a3sg;
|
||||
|
||||
extern void sh7372_init_pm_domain(struct sh7372_pm_domain *sh7372_pd);
|
||||
extern void sh7372_add_device_to_domain(struct sh7372_pm_domain *sh7372_pd,
|
||||
struct platform_device *pdev);
|
||||
#else
|
||||
#define sh7372_init_pm_domain(pd) do { } while(0)
|
||||
#define sh7372_add_device_to_domain(pd, pdev) do { } while(0)
|
||||
#endif /* CONFIG_PM */
|
||||
|
||||
#endif /* __ASM_SH7372_H__ */
|
||||
|
|
|
@ -15,16 +15,176 @@
|
|||
#include <linux/list.h>
|
||||
#include <linux/err.h>
|
||||
#include <linux/slab.h>
|
||||
#include <linux/pm_runtime.h>
|
||||
#include <linux/platform_device.h>
|
||||
#include <linux/delay.h>
|
||||
#include <asm/system.h>
|
||||
#include <asm/io.h>
|
||||
#include <asm/tlbflush.h>
|
||||
#include <mach/common.h>
|
||||
#include <mach/sh7372.h>
|
||||
|
||||
#define SMFRAM 0xe6a70000
|
||||
#define SYSTBCR 0xe6150024
|
||||
#define SBAR 0xe6180020
|
||||
#define APARMBAREA 0xe6f10020
|
||||
|
||||
#define SPDCR 0xe6180008
|
||||
#define SWUCR 0xe6180014
|
||||
#define PSTR 0xe6180080
|
||||
|
||||
#define PSTR_RETRIES 100
|
||||
#define PSTR_DELAY_US 10
|
||||
|
||||
#ifdef CONFIG_PM
|
||||
|
||||
static int pd_power_down(struct generic_pm_domain *genpd)
|
||||
{
|
||||
struct sh7372_pm_domain *sh7372_pd = to_sh7372_pd(genpd);
|
||||
unsigned int mask = 1 << sh7372_pd->bit_shift;
|
||||
|
||||
if (__raw_readl(PSTR) & mask) {
|
||||
unsigned int retry_count;
|
||||
|
||||
__raw_writel(mask, SPDCR);
|
||||
|
||||
for (retry_count = PSTR_RETRIES; retry_count; retry_count--) {
|
||||
if (!(__raw_readl(SPDCR) & mask))
|
||||
break;
|
||||
cpu_relax();
|
||||
}
|
||||
}
|
||||
|
||||
pr_debug("sh7372 power domain down 0x%08x -> PSTR = 0x%08x\n",
|
||||
mask, __raw_readl(PSTR));
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int pd_power_up(struct generic_pm_domain *genpd)
|
||||
{
|
||||
struct sh7372_pm_domain *sh7372_pd = to_sh7372_pd(genpd);
|
||||
unsigned int mask = 1 << sh7372_pd->bit_shift;
|
||||
unsigned int retry_count;
|
||||
int ret = 0;
|
||||
|
||||
if (__raw_readl(PSTR) & mask)
|
||||
goto out;
|
||||
|
||||
__raw_writel(mask, SWUCR);
|
||||
|
||||
for (retry_count = 2 * PSTR_RETRIES; retry_count; retry_count--) {
|
||||
if (!(__raw_readl(SWUCR) & mask))
|
||||
goto out;
|
||||
if (retry_count > PSTR_RETRIES)
|
||||
udelay(PSTR_DELAY_US);
|
||||
else
|
||||
cpu_relax();
|
||||
}
|
||||
if (__raw_readl(SWUCR) & mask)
|
||||
ret = -EIO;
|
||||
|
||||
out:
|
||||
pr_debug("sh7372 power domain up 0x%08x -> PSTR = 0x%08x\n",
|
||||
mask, __raw_readl(PSTR));
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int pd_power_up_a3rv(struct generic_pm_domain *genpd)
|
||||
{
|
||||
int ret = pd_power_up(genpd);
|
||||
|
||||
/* force A4LC on after A3RV has been requested on */
|
||||
pm_genpd_poweron(&sh7372_a4lc.genpd);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int pd_power_down_a3rv(struct generic_pm_domain *genpd)
|
||||
{
|
||||
int ret = pd_power_down(genpd);
|
||||
|
||||
/* try to power down A4LC after A3RV is requested off */
|
||||
genpd_queue_power_off_work(&sh7372_a4lc.genpd);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int pd_power_down_a4lc(struct generic_pm_domain *genpd)
|
||||
{
|
||||
/* only power down A4LC if A3RV is off */
|
||||
if (!(__raw_readl(PSTR) & (1 << sh7372_a3rv.bit_shift)))
|
||||
return pd_power_down(genpd);
|
||||
|
||||
return -EBUSY;
|
||||
}
|
||||
|
||||
static bool pd_active_wakeup(struct device *dev)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
void sh7372_init_pm_domain(struct sh7372_pm_domain *sh7372_pd)
|
||||
{
|
||||
struct generic_pm_domain *genpd = &sh7372_pd->genpd;
|
||||
|
||||
pm_genpd_init(genpd, NULL, false);
|
||||
genpd->stop_device = pm_clk_suspend;
|
||||
genpd->start_device = pm_clk_resume;
|
||||
genpd->active_wakeup = pd_active_wakeup;
|
||||
|
||||
if (sh7372_pd == &sh7372_a4lc) {
|
||||
genpd->power_off = pd_power_down_a4lc;
|
||||
genpd->power_on = pd_power_up;
|
||||
} else if (sh7372_pd == &sh7372_a3rv) {
|
||||
genpd->power_off = pd_power_down_a3rv;
|
||||
genpd->power_on = pd_power_up_a3rv;
|
||||
} else {
|
||||
genpd->power_off = pd_power_down;
|
||||
genpd->power_on = pd_power_up;
|
||||
}
|
||||
genpd->power_on(&sh7372_pd->genpd);
|
||||
}
|
||||
|
||||
void sh7372_add_device_to_domain(struct sh7372_pm_domain *sh7372_pd,
|
||||
struct platform_device *pdev)
|
||||
{
|
||||
struct device *dev = &pdev->dev;
|
||||
|
||||
if (!dev->power.subsys_data) {
|
||||
pm_clk_init(dev);
|
||||
pm_clk_add(dev, NULL);
|
||||
}
|
||||
pm_genpd_add_device(&sh7372_pd->genpd, dev);
|
||||
}
|
||||
|
||||
struct sh7372_pm_domain sh7372_a4lc = {
|
||||
.bit_shift = 1,
|
||||
};
|
||||
|
||||
struct sh7372_pm_domain sh7372_a4mp = {
|
||||
.bit_shift = 2,
|
||||
};
|
||||
|
||||
struct sh7372_pm_domain sh7372_d4 = {
|
||||
.bit_shift = 3,
|
||||
};
|
||||
|
||||
struct sh7372_pm_domain sh7372_a3rv = {
|
||||
.bit_shift = 6,
|
||||
};
|
||||
|
||||
struct sh7372_pm_domain sh7372_a3ri = {
|
||||
.bit_shift = 8,
|
||||
};
|
||||
|
||||
struct sh7372_pm_domain sh7372_a3sg = {
|
||||
.bit_shift = 13,
|
||||
};
|
||||
|
||||
#endif /* CONFIG_PM */
|
||||
|
||||
static void sh7372_enter_core_standby(void)
|
||||
{
|
||||
void __iomem *smfram = (void __iomem *)SMFRAM;
|
||||
|
|
|
@ -14,6 +14,7 @@
|
|||
#include <linux/kernel.h>
|
||||
#include <linux/io.h>
|
||||
#include <linux/pm_runtime.h>
|
||||
#include <linux/pm_domain.h>
|
||||
#include <linux/platform_device.h>
|
||||
#include <linux/clk.h>
|
||||
#include <linux/sh_clk.h>
|
||||
|
@ -28,31 +29,38 @@ static int default_platform_runtime_idle(struct device *dev)
|
|||
return pm_runtime_suspend(dev);
|
||||
}
|
||||
|
||||
static struct dev_power_domain default_power_domain = {
|
||||
static struct dev_pm_domain default_pm_domain = {
|
||||
.ops = {
|
||||
.runtime_suspend = pm_runtime_clk_suspend,
|
||||
.runtime_resume = pm_runtime_clk_resume,
|
||||
.runtime_suspend = pm_clk_suspend,
|
||||
.runtime_resume = pm_clk_resume,
|
||||
.runtime_idle = default_platform_runtime_idle,
|
||||
USE_PLATFORM_PM_SLEEP_OPS
|
||||
},
|
||||
};
|
||||
|
||||
#define DEFAULT_PWR_DOMAIN_PTR (&default_power_domain)
|
||||
#define DEFAULT_PM_DOMAIN_PTR (&default_pm_domain)
|
||||
|
||||
#else
|
||||
|
||||
#define DEFAULT_PWR_DOMAIN_PTR NULL
|
||||
#define DEFAULT_PM_DOMAIN_PTR NULL
|
||||
|
||||
#endif /* CONFIG_PM_RUNTIME */
|
||||
|
||||
static struct pm_clk_notifier_block platform_bus_notifier = {
|
||||
.pwr_domain = DEFAULT_PWR_DOMAIN_PTR,
|
||||
.pm_domain = DEFAULT_PM_DOMAIN_PTR,
|
||||
.con_ids = { NULL, },
|
||||
};
|
||||
|
||||
static int __init sh_pm_runtime_init(void)
|
||||
{
|
||||
pm_runtime_clk_add_notifier(&platform_bus_type, &platform_bus_notifier);
|
||||
pm_clk_add_notifier(&platform_bus_type, &platform_bus_notifier);
|
||||
return 0;
|
||||
}
|
||||
core_initcall(sh_pm_runtime_init);
|
||||
|
||||
static int __init sh_pm_runtime_late_init(void)
|
||||
{
|
||||
pm_genpd_poweroff_unused();
|
||||
return 0;
|
||||
}
|
||||
late_initcall(sh_pm_runtime_late_init);
|
||||
|
|
|
@ -841,11 +841,22 @@ static struct platform_device *sh7372_late_devices[] __initdata = {
|
|||
|
||||
void __init sh7372_add_standard_devices(void)
|
||||
{
|
||||
sh7372_init_pm_domain(&sh7372_a4lc);
|
||||
sh7372_init_pm_domain(&sh7372_a4mp);
|
||||
sh7372_init_pm_domain(&sh7372_d4);
|
||||
sh7372_init_pm_domain(&sh7372_a3rv);
|
||||
sh7372_init_pm_domain(&sh7372_a3ri);
|
||||
sh7372_init_pm_domain(&sh7372_a3sg);
|
||||
|
||||
platform_add_devices(sh7372_early_devices,
|
||||
ARRAY_SIZE(sh7372_early_devices));
|
||||
|
||||
platform_add_devices(sh7372_late_devices,
|
||||
ARRAY_SIZE(sh7372_late_devices));
|
||||
|
||||
sh7372_add_device_to_domain(&sh7372_a3rv, &vpu_device);
|
||||
sh7372_add_device_to_domain(&sh7372_a4mp, &spu0_device);
|
||||
sh7372_add_device_to_domain(&sh7372_a4mp, &spu1_device);
|
||||
}
|
||||
|
||||
void __init sh7372_add_early_devices(void)
|
||||
|
|
|
@ -44,6 +44,10 @@ extern struct device omap_device_parent;
|
|||
#define OMAP_DEVICE_STATE_IDLE 2
|
||||
#define OMAP_DEVICE_STATE_SHUTDOWN 3
|
||||
|
||||
/* omap_device.flags values */
|
||||
#define OMAP_DEVICE_SUSPENDED BIT(0)
|
||||
#define OMAP_DEVICE_NO_IDLE_ON_SUSPEND BIT(1)
|
||||
|
||||
/**
|
||||
* struct omap_device - omap_device wrapper for platform_devices
|
||||
* @pdev: platform_device
|
||||
|
@ -73,6 +77,7 @@ struct omap_device {
|
|||
s8 pm_lat_level;
|
||||
u8 hwmods_cnt;
|
||||
u8 _state;
|
||||
u8 flags;
|
||||
};
|
||||
|
||||
/* Device driver interface (call via platform_data fn ptrs) */
|
||||
|
@ -117,6 +122,10 @@ int omap_device_enable_hwmods(struct omap_device *od);
|
|||
int omap_device_disable_clocks(struct omap_device *od);
|
||||
int omap_device_enable_clocks(struct omap_device *od);
|
||||
|
||||
static inline void omap_device_disable_idle_on_suspend(struct omap_device *od)
|
||||
{
|
||||
od->flags |= OMAP_DEVICE_NO_IDLE_ON_SUSPEND;
|
||||
}
|
||||
|
||||
/*
|
||||
* Entries should be kept in latency order ascending
|
||||
|
|
|
@ -537,6 +537,7 @@ int omap_early_device_register(struct omap_device *od)
|
|||
return 0;
|
||||
}
|
||||
|
||||
#ifdef CONFIG_PM_RUNTIME
|
||||
static int _od_runtime_suspend(struct device *dev)
|
||||
{
|
||||
struct platform_device *pdev = to_platform_device(dev);
|
||||
|
@ -563,13 +564,55 @@ static int _od_runtime_resume(struct device *dev)
|
|||
|
||||
return pm_generic_runtime_resume(dev);
|
||||
}
|
||||
#endif
|
||||
|
||||
static struct dev_power_domain omap_device_power_domain = {
|
||||
#ifdef CONFIG_SUSPEND
|
||||
static int _od_suspend_noirq(struct device *dev)
|
||||
{
|
||||
struct platform_device *pdev = to_platform_device(dev);
|
||||
struct omap_device *od = to_omap_device(pdev);
|
||||
int ret;
|
||||
|
||||
if (od->flags & OMAP_DEVICE_NO_IDLE_ON_SUSPEND)
|
||||
return pm_generic_suspend_noirq(dev);
|
||||
|
||||
ret = pm_generic_suspend_noirq(dev);
|
||||
|
||||
if (!ret && !pm_runtime_status_suspended(dev)) {
|
||||
if (pm_generic_runtime_suspend(dev) == 0) {
|
||||
omap_device_idle(pdev);
|
||||
od->flags |= OMAP_DEVICE_SUSPENDED;
|
||||
}
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int _od_resume_noirq(struct device *dev)
|
||||
{
|
||||
struct platform_device *pdev = to_platform_device(dev);
|
||||
struct omap_device *od = to_omap_device(pdev);
|
||||
|
||||
if (od->flags & OMAP_DEVICE_NO_IDLE_ON_SUSPEND)
|
||||
return pm_generic_resume_noirq(dev);
|
||||
|
||||
if ((od->flags & OMAP_DEVICE_SUSPENDED) &&
|
||||
!pm_runtime_status_suspended(dev)) {
|
||||
od->flags &= ~OMAP_DEVICE_SUSPENDED;
|
||||
omap_device_enable(pdev);
|
||||
pm_generic_runtime_resume(dev);
|
||||
}
|
||||
|
||||
return pm_generic_resume_noirq(dev);
|
||||
}
|
||||
#endif
|
||||
|
||||
static struct dev_pm_domain omap_device_pm_domain = {
|
||||
.ops = {
|
||||
.runtime_suspend = _od_runtime_suspend,
|
||||
.runtime_idle = _od_runtime_idle,
|
||||
.runtime_resume = _od_runtime_resume,
|
||||
SET_RUNTIME_PM_OPS(_od_runtime_suspend, _od_runtime_resume,
|
||||
_od_runtime_idle)
|
||||
USE_PLATFORM_PM_SLEEP_OPS
|
||||
SET_SYSTEM_SLEEP_PM_OPS(_od_suspend_noirq, _od_resume_noirq)
|
||||
}
|
||||
};
|
||||
|
||||
|
@ -586,7 +629,7 @@ int omap_device_register(struct omap_device *od)
|
|||
pr_debug("omap_device: %s: registering\n", od->pdev.name);
|
||||
|
||||
od->pdev.dev.parent = &omap_device_parent;
|
||||
od->pdev.dev.pwr_domain = &omap_device_power_domain;
|
||||
od->pdev.dev.pm_domain = &omap_device_pm_domain;
|
||||
return platform_device_register(&od->pdev);
|
||||
}
|
||||
|
||||
|
|
|
@ -256,7 +256,7 @@ out:
|
|||
return ret;
|
||||
}
|
||||
|
||||
static struct dev_power_domain default_power_domain = {
|
||||
static struct dev_pm_domain default_pm_domain = {
|
||||
.ops = {
|
||||
.runtime_suspend = default_platform_runtime_suspend,
|
||||
.runtime_resume = default_platform_runtime_resume,
|
||||
|
@ -285,7 +285,7 @@ static int platform_bus_notify(struct notifier_block *nb,
|
|||
hwblk_disable(hwblk_info, hwblk);
|
||||
/* make sure driver re-inits itself once */
|
||||
__set_bit(PDEV_ARCHDATA_FLAG_INIT, &pdev->archdata.flags);
|
||||
dev->pwr_domain = &default_power_domain;
|
||||
dev->pm_domain = &default_pm_domain;
|
||||
break;
|
||||
/* TODO: add BUS_NOTIFY_BIND_DRIVER and increase idle count */
|
||||
case BUS_NOTIFY_BOUND_DRIVER:
|
||||
|
@ -299,7 +299,7 @@ static int platform_bus_notify(struct notifier_block *nb,
|
|||
__set_bit(PDEV_ARCHDATA_FLAG_INIT, &pdev->archdata.flags);
|
||||
break;
|
||||
case BUS_NOTIFY_DEL_DEVICE:
|
||||
dev->pwr_domain = NULL;
|
||||
dev->pm_domain = NULL;
|
||||
break;
|
||||
}
|
||||
return 0;
|
||||
|
|
|
@ -3,6 +3,7 @@ obj-$(CONFIG_PM_SLEEP) += main.o wakeup.o
|
|||
obj-$(CONFIG_PM_RUNTIME) += runtime.o
|
||||
obj-$(CONFIG_PM_TRACE_RTC) += trace.o
|
||||
obj-$(CONFIG_PM_OPP) += opp.o
|
||||
obj-$(CONFIG_PM_GENERIC_DOMAINS) += domain.o
|
||||
obj-$(CONFIG_HAVE_CLK) += clock_ops.o
|
||||
|
||||
ccflags-$(CONFIG_DEBUG_DRIVER) := -DDEBUG
|
|
@ -15,9 +15,9 @@
|
|||
#include <linux/slab.h>
|
||||
#include <linux/err.h>
|
||||
|
||||
#ifdef CONFIG_PM_RUNTIME
|
||||
#ifdef CONFIG_PM
|
||||
|
||||
struct pm_runtime_clk_data {
|
||||
struct pm_clk_data {
|
||||
struct list_head clock_list;
|
||||
struct mutex lock;
|
||||
};
|
||||
|
@ -36,25 +36,25 @@ struct pm_clock_entry {
|
|||
enum pce_status status;
|
||||
};
|
||||
|
||||
static struct pm_runtime_clk_data *__to_prd(struct device *dev)
|
||||
static struct pm_clk_data *__to_pcd(struct device *dev)
|
||||
{
|
||||
return dev ? dev->power.subsys_data : NULL;
|
||||
}
|
||||
|
||||
/**
|
||||
* pm_runtime_clk_add - Start using a device clock for runtime PM.
|
||||
* @dev: Device whose clock is going to be used for runtime PM.
|
||||
* pm_clk_add - Start using a device clock for power management.
|
||||
* @dev: Device whose clock is going to be used for power management.
|
||||
* @con_id: Connection ID of the clock.
|
||||
*
|
||||
* Add the clock represented by @con_id to the list of clocks used for
|
||||
* the runtime PM of @dev.
|
||||
* the power management of @dev.
|
||||
*/
|
||||
int pm_runtime_clk_add(struct device *dev, const char *con_id)
|
||||
int pm_clk_add(struct device *dev, const char *con_id)
|
||||
{
|
||||
struct pm_runtime_clk_data *prd = __to_prd(dev);
|
||||
struct pm_clk_data *pcd = __to_pcd(dev);
|
||||
struct pm_clock_entry *ce;
|
||||
|
||||
if (!prd)
|
||||
if (!pcd)
|
||||
return -EINVAL;
|
||||
|
||||
ce = kzalloc(sizeof(*ce), GFP_KERNEL);
|
||||
|
@ -73,20 +73,20 @@ int pm_runtime_clk_add(struct device *dev, const char *con_id)
|
|||
}
|
||||
}
|
||||
|
||||
mutex_lock(&prd->lock);
|
||||
list_add_tail(&ce->node, &prd->clock_list);
|
||||
mutex_unlock(&prd->lock);
|
||||
mutex_lock(&pcd->lock);
|
||||
list_add_tail(&ce->node, &pcd->clock_list);
|
||||
mutex_unlock(&pcd->lock);
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* __pm_runtime_clk_remove - Destroy runtime PM clock entry.
|
||||
* @ce: Runtime PM clock entry to destroy.
|
||||
* __pm_clk_remove - Destroy PM clock entry.
|
||||
* @ce: PM clock entry to destroy.
|
||||
*
|
||||
* This routine must be called under the mutex protecting the runtime PM list
|
||||
* of clocks corresponding the the @ce's device.
|
||||
* This routine must be called under the mutex protecting the PM list of clocks
|
||||
* corresponding the the @ce's device.
|
||||
*/
|
||||
static void __pm_runtime_clk_remove(struct pm_clock_entry *ce)
|
||||
static void __pm_clk_remove(struct pm_clock_entry *ce)
|
||||
{
|
||||
if (!ce)
|
||||
return;
|
||||
|
@ -108,95 +108,99 @@ static void __pm_runtime_clk_remove(struct pm_clock_entry *ce)
|
|||
}
|
||||
|
||||
/**
|
||||
* pm_runtime_clk_remove - Stop using a device clock for runtime PM.
|
||||
* @dev: Device whose clock should not be used for runtime PM any more.
|
||||
* pm_clk_remove - Stop using a device clock for power management.
|
||||
* @dev: Device whose clock should not be used for PM any more.
|
||||
* @con_id: Connection ID of the clock.
|
||||
*
|
||||
* Remove the clock represented by @con_id from the list of clocks used for
|
||||
* the runtime PM of @dev.
|
||||
* the power management of @dev.
|
||||
*/
|
||||
void pm_runtime_clk_remove(struct device *dev, const char *con_id)
|
||||
void pm_clk_remove(struct device *dev, const char *con_id)
|
||||
{
|
||||
struct pm_runtime_clk_data *prd = __to_prd(dev);
|
||||
struct pm_clk_data *pcd = __to_pcd(dev);
|
||||
struct pm_clock_entry *ce;
|
||||
|
||||
if (!prd)
|
||||
if (!pcd)
|
||||
return;
|
||||
|
||||
mutex_lock(&prd->lock);
|
||||
mutex_lock(&pcd->lock);
|
||||
|
||||
list_for_each_entry(ce, &prd->clock_list, node) {
|
||||
list_for_each_entry(ce, &pcd->clock_list, node) {
|
||||
if (!con_id && !ce->con_id) {
|
||||
__pm_runtime_clk_remove(ce);
|
||||
__pm_clk_remove(ce);
|
||||
break;
|
||||
} else if (!con_id || !ce->con_id) {
|
||||
continue;
|
||||
} else if (!strcmp(con_id, ce->con_id)) {
|
||||
__pm_runtime_clk_remove(ce);
|
||||
__pm_clk_remove(ce);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
mutex_unlock(&prd->lock);
|
||||
mutex_unlock(&pcd->lock);
|
||||
}
|
||||
|
||||
/**
|
||||
* pm_runtime_clk_init - Initialize a device's list of runtime PM clocks.
|
||||
* @dev: Device to initialize the list of runtime PM clocks for.
|
||||
* pm_clk_init - Initialize a device's list of power management clocks.
|
||||
* @dev: Device to initialize the list of PM clocks for.
|
||||
*
|
||||
* Allocate a struct pm_runtime_clk_data object, initialize its lock member and
|
||||
* Allocate a struct pm_clk_data object, initialize its lock member and
|
||||
* make the @dev's power.subsys_data field point to it.
|
||||
*/
|
||||
int pm_runtime_clk_init(struct device *dev)
|
||||
int pm_clk_init(struct device *dev)
|
||||
{
|
||||
struct pm_runtime_clk_data *prd;
|
||||
struct pm_clk_data *pcd;
|
||||
|
||||
prd = kzalloc(sizeof(*prd), GFP_KERNEL);
|
||||
if (!prd) {
|
||||
dev_err(dev, "Not enough memory fo runtime PM data.\n");
|
||||
pcd = kzalloc(sizeof(*pcd), GFP_KERNEL);
|
||||
if (!pcd) {
|
||||
dev_err(dev, "Not enough memory for PM clock data.\n");
|
||||
return -ENOMEM;
|
||||
}
|
||||
|
||||
INIT_LIST_HEAD(&prd->clock_list);
|
||||
mutex_init(&prd->lock);
|
||||
dev->power.subsys_data = prd;
|
||||
INIT_LIST_HEAD(&pcd->clock_list);
|
||||
mutex_init(&pcd->lock);
|
||||
dev->power.subsys_data = pcd;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* pm_runtime_clk_destroy - Destroy a device's list of runtime PM clocks.
|
||||
* @dev: Device to destroy the list of runtime PM clocks for.
|
||||
* pm_clk_destroy - Destroy a device's list of power management clocks.
|
||||
* @dev: Device to destroy the list of PM clocks for.
|
||||
*
|
||||
* Clear the @dev's power.subsys_data field, remove the list of clock entries
|
||||
* from the struct pm_runtime_clk_data object pointed to by it before and free
|
||||
* from the struct pm_clk_data object pointed to by it before and free
|
||||
* that object.
|
||||
*/
|
||||
void pm_runtime_clk_destroy(struct device *dev)
|
||||
void pm_clk_destroy(struct device *dev)
|
||||
{
|
||||
struct pm_runtime_clk_data *prd = __to_prd(dev);
|
||||
struct pm_clk_data *pcd = __to_pcd(dev);
|
||||
struct pm_clock_entry *ce, *c;
|
||||
|
||||
if (!prd)
|
||||
if (!pcd)
|
||||
return;
|
||||
|
||||
dev->power.subsys_data = NULL;
|
||||
|
||||
mutex_lock(&prd->lock);
|
||||
mutex_lock(&pcd->lock);
|
||||
|
||||
list_for_each_entry_safe_reverse(ce, c, &prd->clock_list, node)
|
||||
__pm_runtime_clk_remove(ce);
|
||||
list_for_each_entry_safe_reverse(ce, c, &pcd->clock_list, node)
|
||||
__pm_clk_remove(ce);
|
||||
|
||||
mutex_unlock(&prd->lock);
|
||||
mutex_unlock(&pcd->lock);
|
||||
|
||||
kfree(prd);
|
||||
kfree(pcd);
|
||||
}
|
||||
|
||||
#endif /* CONFIG_PM */
|
||||
|
||||
#ifdef CONFIG_PM_RUNTIME
|
||||
|
||||
/**
|
||||
* pm_runtime_clk_acquire - Acquire a device clock.
|
||||
* pm_clk_acquire - Acquire a device clock.
|
||||
* @dev: Device whose clock is to be acquired.
|
||||
* @con_id: Connection ID of the clock.
|
||||
*/
|
||||
static void pm_runtime_clk_acquire(struct device *dev,
|
||||
static void pm_clk_acquire(struct device *dev,
|
||||
struct pm_clock_entry *ce)
|
||||
{
|
||||
ce->clk = clk_get(dev, ce->con_id);
|
||||
|
@ -209,24 +213,24 @@ static void pm_runtime_clk_acquire(struct device *dev,
|
|||
}
|
||||
|
||||
/**
|
||||
* pm_runtime_clk_suspend - Disable clocks in a device's runtime PM clock list.
|
||||
* pm_clk_suspend - Disable clocks in a device's PM clock list.
|
||||
* @dev: Device to disable the clocks for.
|
||||
*/
|
||||
int pm_runtime_clk_suspend(struct device *dev)
|
||||
int pm_clk_suspend(struct device *dev)
|
||||
{
|
||||
struct pm_runtime_clk_data *prd = __to_prd(dev);
|
||||
struct pm_clk_data *pcd = __to_pcd(dev);
|
||||
struct pm_clock_entry *ce;
|
||||
|
||||
dev_dbg(dev, "%s()\n", __func__);
|
||||
|
||||
if (!prd)
|
||||
if (!pcd)
|
||||
return 0;
|
||||
|
||||
mutex_lock(&prd->lock);
|
||||
mutex_lock(&pcd->lock);
|
||||
|
||||
list_for_each_entry_reverse(ce, &prd->clock_list, node) {
|
||||
list_for_each_entry_reverse(ce, &pcd->clock_list, node) {
|
||||
if (ce->status == PCE_STATUS_NONE)
|
||||
pm_runtime_clk_acquire(dev, ce);
|
||||
pm_clk_acquire(dev, ce);
|
||||
|
||||
if (ce->status < PCE_STATUS_ERROR) {
|
||||
clk_disable(ce->clk);
|
||||
|
@ -234,30 +238,30 @@ int pm_runtime_clk_suspend(struct device *dev)
|
|||
}
|
||||
}
|
||||
|
||||
mutex_unlock(&prd->lock);
|
||||
mutex_unlock(&pcd->lock);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* pm_runtime_clk_resume - Enable clocks in a device's runtime PM clock list.
|
||||
* pm_clk_resume - Enable clocks in a device's PM clock list.
|
||||
* @dev: Device to enable the clocks for.
|
||||
*/
|
||||
int pm_runtime_clk_resume(struct device *dev)
|
||||
int pm_clk_resume(struct device *dev)
|
||||
{
|
||||
struct pm_runtime_clk_data *prd = __to_prd(dev);
|
||||
struct pm_clk_data *pcd = __to_pcd(dev);
|
||||
struct pm_clock_entry *ce;
|
||||
|
||||
dev_dbg(dev, "%s()\n", __func__);
|
||||
|
||||
if (!prd)
|
||||
if (!pcd)
|
||||
return 0;
|
||||
|
||||
mutex_lock(&prd->lock);
|
||||
mutex_lock(&pcd->lock);
|
||||
|
||||
list_for_each_entry(ce, &prd->clock_list, node) {
|
||||
list_for_each_entry(ce, &pcd->clock_list, node) {
|
||||
if (ce->status == PCE_STATUS_NONE)
|
||||
pm_runtime_clk_acquire(dev, ce);
|
||||
pm_clk_acquire(dev, ce);
|
||||
|
||||
if (ce->status < PCE_STATUS_ERROR) {
|
||||
clk_enable(ce->clk);
|
||||
|
@ -265,28 +269,28 @@ int pm_runtime_clk_resume(struct device *dev)
|
|||
}
|
||||
}
|
||||
|
||||
mutex_unlock(&prd->lock);
|
||||
mutex_unlock(&pcd->lock);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* pm_runtime_clk_notify - Notify routine for device addition and removal.
|
||||
* pm_clk_notify - Notify routine for device addition and removal.
|
||||
* @nb: Notifier block object this function is a member of.
|
||||
* @action: Operation being carried out by the caller.
|
||||
* @data: Device the routine is being run for.
|
||||
*
|
||||
* For this function to work, @nb must be a member of an object of type
|
||||
* struct pm_clk_notifier_block containing all of the requisite data.
|
||||
* Specifically, the pwr_domain member of that object is copied to the device's
|
||||
* pwr_domain field and its con_ids member is used to populate the device's list
|
||||
* of runtime PM clocks, depending on @action.
|
||||
* Specifically, the pm_domain member of that object is copied to the device's
|
||||
* pm_domain field and its con_ids member is used to populate the device's list
|
||||
* of PM clocks, depending on @action.
|
||||
*
|
||||
* If the device's pwr_domain field is already populated with a value different
|
||||
* If the device's pm_domain field is already populated with a value different
|
||||
* from the one stored in the struct pm_clk_notifier_block object, the function
|
||||
* does nothing.
|
||||
*/
|
||||
static int pm_runtime_clk_notify(struct notifier_block *nb,
|
||||
static int pm_clk_notify(struct notifier_block *nb,
|
||||
unsigned long action, void *data)
|
||||
{
|
||||
struct pm_clk_notifier_block *clknb;
|
||||
|
@ -300,28 +304,28 @@ static int pm_runtime_clk_notify(struct notifier_block *nb,
|
|||
|
||||
switch (action) {
|
||||
case BUS_NOTIFY_ADD_DEVICE:
|
||||
if (dev->pwr_domain)
|
||||
if (dev->pm_domain)
|
||||
break;
|
||||
|
||||
error = pm_runtime_clk_init(dev);
|
||||
error = pm_clk_init(dev);
|
||||
if (error)
|
||||
break;
|
||||
|
||||
dev->pwr_domain = clknb->pwr_domain;
|
||||
dev->pm_domain = clknb->pm_domain;
|
||||
if (clknb->con_ids[0]) {
|
||||
for (con_id = clknb->con_ids; *con_id; con_id++)
|
||||
pm_runtime_clk_add(dev, *con_id);
|
||||
pm_clk_add(dev, *con_id);
|
||||
} else {
|
||||
pm_runtime_clk_add(dev, NULL);
|
||||
pm_clk_add(dev, NULL);
|
||||
}
|
||||
|
||||
break;
|
||||
case BUS_NOTIFY_DEL_DEVICE:
|
||||
if (dev->pwr_domain != clknb->pwr_domain)
|
||||
if (dev->pm_domain != clknb->pm_domain)
|
||||
break;
|
||||
|
||||
dev->pwr_domain = NULL;
|
||||
pm_runtime_clk_destroy(dev);
|
||||
dev->pm_domain = NULL;
|
||||
pm_clk_destroy(dev);
|
||||
break;
|
||||
}
|
||||
|
||||
|
@ -330,6 +334,60 @@ static int pm_runtime_clk_notify(struct notifier_block *nb,
|
|||
|
||||
#else /* !CONFIG_PM_RUNTIME */
|
||||
|
||||
#ifdef CONFIG_PM
|
||||
|
||||
/**
|
||||
* pm_clk_suspend - Disable clocks in a device's PM clock list.
|
||||
* @dev: Device to disable the clocks for.
|
||||
*/
|
||||
int pm_clk_suspend(struct device *dev)
|
||||
{
|
||||
struct pm_clk_data *pcd = __to_pcd(dev);
|
||||
struct pm_clock_entry *ce;
|
||||
|
||||
dev_dbg(dev, "%s()\n", __func__);
|
||||
|
||||
/* If there is no driver, the clocks are already disabled. */
|
||||
if (!pcd || !dev->driver)
|
||||
return 0;
|
||||
|
||||
mutex_lock(&pcd->lock);
|
||||
|
||||
list_for_each_entry_reverse(ce, &pcd->clock_list, node)
|
||||
clk_disable(ce->clk);
|
||||
|
||||
mutex_unlock(&pcd->lock);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* pm_clk_resume - Enable clocks in a device's PM clock list.
|
||||
* @dev: Device to enable the clocks for.
|
||||
*/
|
||||
int pm_clk_resume(struct device *dev)
|
||||
{
|
||||
struct pm_clk_data *pcd = __to_pcd(dev);
|
||||
struct pm_clock_entry *ce;
|
||||
|
||||
dev_dbg(dev, "%s()\n", __func__);
|
||||
|
||||
/* If there is no driver, the clocks should remain disabled. */
|
||||
if (!pcd || !dev->driver)
|
||||
return 0;
|
||||
|
||||
mutex_lock(&pcd->lock);
|
||||
|
||||
list_for_each_entry(ce, &pcd->clock_list, node)
|
||||
clk_enable(ce->clk);
|
||||
|
||||
mutex_unlock(&pcd->lock);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
#endif /* CONFIG_PM */
|
||||
|
||||
/**
|
||||
* enable_clock - Enable a device clock.
|
||||
* @dev: Device whose clock is to be enabled.
|
||||
|
@ -365,7 +423,7 @@ static void disable_clock(struct device *dev, const char *con_id)
|
|||
}
|
||||
|
||||
/**
|
||||
* pm_runtime_clk_notify - Notify routine for device addition and removal.
|
||||
* pm_clk_notify - Notify routine for device addition and removal.
|
||||
* @nb: Notifier block object this function is a member of.
|
||||
* @action: Operation being carried out by the caller.
|
||||
* @data: Device the routine is being run for.
|
||||
|
@ -375,7 +433,7 @@ static void disable_clock(struct device *dev, const char *con_id)
|
|||
* Specifically, the con_ids member of that object is used to enable or disable
|
||||
* the device's clocks, depending on @action.
|
||||
*/
|
||||
static int pm_runtime_clk_notify(struct notifier_block *nb,
|
||||
static int pm_clk_notify(struct notifier_block *nb,
|
||||
unsigned long action, void *data)
|
||||
{
|
||||
struct pm_clk_notifier_block *clknb;
|
||||
|
@ -411,21 +469,21 @@ static int pm_runtime_clk_notify(struct notifier_block *nb,
|
|||
#endif /* !CONFIG_PM_RUNTIME */
|
||||
|
||||
/**
|
||||
* pm_runtime_clk_add_notifier - Add bus type notifier for runtime PM clocks.
|
||||
* pm_clk_add_notifier - Add bus type notifier for power management clocks.
|
||||
* @bus: Bus type to add the notifier to.
|
||||
* @clknb: Notifier to be added to the given bus type.
|
||||
*
|
||||
* The nb member of @clknb is not expected to be initialized and its
|
||||
* notifier_call member will be replaced with pm_runtime_clk_notify(). However,
|
||||
* notifier_call member will be replaced with pm_clk_notify(). However,
|
||||
* the remaining members of @clknb should be populated prior to calling this
|
||||
* routine.
|
||||
*/
|
||||
void pm_runtime_clk_add_notifier(struct bus_type *bus,
|
||||
void pm_clk_add_notifier(struct bus_type *bus,
|
||||
struct pm_clk_notifier_block *clknb)
|
||||
{
|
||||
if (!bus || !clknb)
|
||||
return;
|
||||
|
||||
clknb->nb.notifier_call = pm_runtime_clk_notify;
|
||||
clknb->nb.notifier_call = pm_clk_notify;
|
||||
bus_register_notifier(bus, &clknb->nb);
|
||||
}
|
||||
|
|
1273
drivers/base/power/domain.c
Normal file
1273
drivers/base/power/domain.c
Normal file
File diff suppressed because it is too large
Load diff
|
@ -94,12 +94,13 @@ int pm_generic_prepare(struct device *dev)
|
|||
* __pm_generic_call - Generic suspend/freeze/poweroff/thaw subsystem callback.
|
||||
* @dev: Device to handle.
|
||||
* @event: PM transition of the system under way.
|
||||
* @bool: Whether or not this is the "noirq" stage.
|
||||
*
|
||||
* If the device has not been suspended at run time, execute the
|
||||
* suspend/freeze/poweroff/thaw callback provided by its driver, if defined, and
|
||||
* return its error code. Otherwise, return zero.
|
||||
*/
|
||||
static int __pm_generic_call(struct device *dev, int event)
|
||||
static int __pm_generic_call(struct device *dev, int event, bool noirq)
|
||||
{
|
||||
const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
|
||||
int (*callback)(struct device *);
|
||||
|
@ -109,16 +110,16 @@ static int __pm_generic_call(struct device *dev, int event)
|
|||
|
||||
switch (event) {
|
||||
case PM_EVENT_SUSPEND:
|
||||
callback = pm->suspend;
|
||||
callback = noirq ? pm->suspend_noirq : pm->suspend;
|
||||
break;
|
||||
case PM_EVENT_FREEZE:
|
||||
callback = pm->freeze;
|
||||
callback = noirq ? pm->freeze_noirq : pm->freeze;
|
||||
break;
|
||||
case PM_EVENT_HIBERNATE:
|
||||
callback = pm->poweroff;
|
||||
callback = noirq ? pm->poweroff_noirq : pm->poweroff;
|
||||
break;
|
||||
case PM_EVENT_THAW:
|
||||
callback = pm->thaw;
|
||||
callback = noirq ? pm->thaw_noirq : pm->thaw;
|
||||
break;
|
||||
default:
|
||||
callback = NULL;
|
||||
|
@ -128,43 +129,83 @@ static int __pm_generic_call(struct device *dev, int event)
|
|||
return callback ? callback(dev) : 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* pm_generic_suspend_noirq - Generic suspend_noirq callback for subsystems.
|
||||
* @dev: Device to suspend.
|
||||
*/
|
||||
int pm_generic_suspend_noirq(struct device *dev)
|
||||
{
|
||||
return __pm_generic_call(dev, PM_EVENT_SUSPEND, true);
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(pm_generic_suspend_noirq);
|
||||
|
||||
/**
|
||||
* pm_generic_suspend - Generic suspend callback for subsystems.
|
||||
* @dev: Device to suspend.
|
||||
*/
|
||||
int pm_generic_suspend(struct device *dev)
|
||||
{
|
||||
return __pm_generic_call(dev, PM_EVENT_SUSPEND);
|
||||
return __pm_generic_call(dev, PM_EVENT_SUSPEND, false);
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(pm_generic_suspend);
|
||||
|
||||
/**
|
||||
* pm_generic_freeze_noirq - Generic freeze_noirq callback for subsystems.
|
||||
* @dev: Device to freeze.
|
||||
*/
|
||||
int pm_generic_freeze_noirq(struct device *dev)
|
||||
{
|
||||
return __pm_generic_call(dev, PM_EVENT_FREEZE, true);
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(pm_generic_freeze_noirq);
|
||||
|
||||
/**
|
||||
* pm_generic_freeze - Generic freeze callback for subsystems.
|
||||
* @dev: Device to freeze.
|
||||
*/
|
||||
int pm_generic_freeze(struct device *dev)
|
||||
{
|
||||
return __pm_generic_call(dev, PM_EVENT_FREEZE);
|
||||
return __pm_generic_call(dev, PM_EVENT_FREEZE, false);
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(pm_generic_freeze);
|
||||
|
||||
/**
|
||||
* pm_generic_poweroff_noirq - Generic poweroff_noirq callback for subsystems.
|
||||
* @dev: Device to handle.
|
||||
*/
|
||||
int pm_generic_poweroff_noirq(struct device *dev)
|
||||
{
|
||||
return __pm_generic_call(dev, PM_EVENT_HIBERNATE, true);
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(pm_generic_poweroff_noirq);
|
||||
|
||||
/**
|
||||
* pm_generic_poweroff - Generic poweroff callback for subsystems.
|
||||
* @dev: Device to handle.
|
||||
*/
|
||||
int pm_generic_poweroff(struct device *dev)
|
||||
{
|
||||
return __pm_generic_call(dev, PM_EVENT_HIBERNATE);
|
||||
return __pm_generic_call(dev, PM_EVENT_HIBERNATE, false);
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(pm_generic_poweroff);
|
||||
|
||||
/**
|
||||
* pm_generic_thaw_noirq - Generic thaw_noirq callback for subsystems.
|
||||
* @dev: Device to thaw.
|
||||
*/
|
||||
int pm_generic_thaw_noirq(struct device *dev)
|
||||
{
|
||||
return __pm_generic_call(dev, PM_EVENT_THAW, true);
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(pm_generic_thaw_noirq);
|
||||
|
||||
/**
|
||||
* pm_generic_thaw - Generic thaw callback for subsystems.
|
||||
* @dev: Device to thaw.
|
||||
*/
|
||||
int pm_generic_thaw(struct device *dev)
|
||||
{
|
||||
return __pm_generic_call(dev, PM_EVENT_THAW);
|
||||
return __pm_generic_call(dev, PM_EVENT_THAW, false);
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(pm_generic_thaw);
|
||||
|
||||
|
@ -172,12 +213,13 @@ EXPORT_SYMBOL_GPL(pm_generic_thaw);
|
|||
* __pm_generic_resume - Generic resume/restore callback for subsystems.
|
||||
* @dev: Device to handle.
|
||||
* @event: PM transition of the system under way.
|
||||
* @bool: Whether or not this is the "noirq" stage.
|
||||
*
|
||||
* Execute the resume/resotre callback provided by the @dev's driver, if
|
||||
* defined. If it returns 0, change the device's runtime PM status to 'active'.
|
||||
* Return the callback's error code.
|
||||
*/
|
||||
static int __pm_generic_resume(struct device *dev, int event)
|
||||
static int __pm_generic_resume(struct device *dev, int event, bool noirq)
|
||||
{
|
||||
const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
|
||||
int (*callback)(struct device *);
|
||||
|
@ -188,10 +230,10 @@ static int __pm_generic_resume(struct device *dev, int event)
|
|||
|
||||
switch (event) {
|
||||
case PM_EVENT_RESUME:
|
||||
callback = pm->resume;
|
||||
callback = noirq ? pm->resume_noirq : pm->resume;
|
||||
break;
|
||||
case PM_EVENT_RESTORE:
|
||||
callback = pm->restore;
|
||||
callback = noirq ? pm->restore_noirq : pm->restore;
|
||||
break;
|
||||
default:
|
||||
callback = NULL;
|
||||
|
@ -202,7 +244,7 @@ static int __pm_generic_resume(struct device *dev, int event)
|
|||
return 0;
|
||||
|
||||
ret = callback(dev);
|
||||
if (!ret && pm_runtime_enabled(dev)) {
|
||||
if (!ret && !noirq && pm_runtime_enabled(dev)) {
|
||||
pm_runtime_disable(dev);
|
||||
pm_runtime_set_active(dev);
|
||||
pm_runtime_enable(dev);
|
||||
|
@ -211,23 +253,43 @@ static int __pm_generic_resume(struct device *dev, int event)
|
|||
return ret;
|
||||
}
|
||||
|
||||
/**
|
||||
* pm_generic_resume_noirq - Generic resume_noirq callback for subsystems.
|
||||
* @dev: Device to resume.
|
||||
*/
|
||||
int pm_generic_resume_noirq(struct device *dev)
|
||||
{
|
||||
return __pm_generic_resume(dev, PM_EVENT_RESUME, true);
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(pm_generic_resume_noirq);
|
||||
|
||||
/**
|
||||
* pm_generic_resume - Generic resume callback for subsystems.
|
||||
* @dev: Device to resume.
|
||||
*/
|
||||
int pm_generic_resume(struct device *dev)
|
||||
{
|
||||
return __pm_generic_resume(dev, PM_EVENT_RESUME);
|
||||
return __pm_generic_resume(dev, PM_EVENT_RESUME, false);
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(pm_generic_resume);
|
||||
|
||||
/**
|
||||
* pm_generic_restore_noirq - Generic restore_noirq callback for subsystems.
|
||||
* @dev: Device to restore.
|
||||
*/
|
||||
int pm_generic_restore_noirq(struct device *dev)
|
||||
{
|
||||
return __pm_generic_resume(dev, PM_EVENT_RESTORE, true);
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(pm_generic_restore_noirq);
|
||||
|
||||
/**
|
||||
* pm_generic_restore - Generic restore callback for subsystems.
|
||||
* @dev: Device to restore.
|
||||
*/
|
||||
int pm_generic_restore(struct device *dev)
|
||||
{
|
||||
return __pm_generic_resume(dev, PM_EVENT_RESTORE);
|
||||
return __pm_generic_resume(dev, PM_EVENT_RESTORE, false);
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(pm_generic_restore);
|
||||
|
||||
|
@ -256,11 +318,17 @@ struct dev_pm_ops generic_subsys_pm_ops = {
|
|||
#ifdef CONFIG_PM_SLEEP
|
||||
.prepare = pm_generic_prepare,
|
||||
.suspend = pm_generic_suspend,
|
||||
.suspend_noirq = pm_generic_suspend_noirq,
|
||||
.resume = pm_generic_resume,
|
||||
.resume_noirq = pm_generic_resume_noirq,
|
||||
.freeze = pm_generic_freeze,
|
||||
.freeze_noirq = pm_generic_freeze_noirq,
|
||||
.thaw = pm_generic_thaw,
|
||||
.thaw_noirq = pm_generic_thaw_noirq,
|
||||
.poweroff = pm_generic_poweroff,
|
||||
.poweroff_noirq = pm_generic_poweroff_noirq,
|
||||
.restore = pm_generic_restore,
|
||||
.restore_noirq = pm_generic_restore_noirq,
|
||||
.complete = pm_generic_complete,
|
||||
#endif
|
||||
#ifdef CONFIG_PM_RUNTIME
|
||||
|
|
|
@ -425,9 +425,9 @@ static int device_resume_noirq(struct device *dev, pm_message_t state)
|
|||
TRACE_DEVICE(dev);
|
||||
TRACE_RESUME(0);
|
||||
|
||||
if (dev->pwr_domain) {
|
||||
if (dev->pm_domain) {
|
||||
pm_dev_dbg(dev, state, "EARLY power domain ");
|
||||
error = pm_noirq_op(dev, &dev->pwr_domain->ops, state);
|
||||
error = pm_noirq_op(dev, &dev->pm_domain->ops, state);
|
||||
} else if (dev->type && dev->type->pm) {
|
||||
pm_dev_dbg(dev, state, "EARLY type ");
|
||||
error = pm_noirq_op(dev, dev->type->pm, state);
|
||||
|
@ -505,6 +505,7 @@ static int legacy_resume(struct device *dev, int (*cb)(struct device *dev))
|
|||
static int device_resume(struct device *dev, pm_message_t state, bool async)
|
||||
{
|
||||
int error = 0;
|
||||
bool put = false;
|
||||
|
||||
TRACE_DEVICE(dev);
|
||||
TRACE_RESUME(0);
|
||||
|
@ -521,9 +522,12 @@ static int device_resume(struct device *dev, pm_message_t state, bool async)
|
|||
if (!dev->power.is_suspended)
|
||||
goto Unlock;
|
||||
|
||||
if (dev->pwr_domain) {
|
||||
pm_runtime_enable(dev);
|
||||
put = true;
|
||||
|
||||
if (dev->pm_domain) {
|
||||
pm_dev_dbg(dev, state, "power domain ");
|
||||
error = pm_op(dev, &dev->pwr_domain->ops, state);
|
||||
error = pm_op(dev, &dev->pm_domain->ops, state);
|
||||
goto End;
|
||||
}
|
||||
|
||||
|
@ -563,6 +567,10 @@ static int device_resume(struct device *dev, pm_message_t state, bool async)
|
|||
complete_all(&dev->power.completion);
|
||||
|
||||
TRACE_RESUME(error);
|
||||
|
||||
if (put)
|
||||
pm_runtime_put_sync(dev);
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
|
@ -641,10 +649,10 @@ static void device_complete(struct device *dev, pm_message_t state)
|
|||
{
|
||||
device_lock(dev);
|
||||
|
||||
if (dev->pwr_domain) {
|
||||
if (dev->pm_domain) {
|
||||
pm_dev_dbg(dev, state, "completing power domain ");
|
||||
if (dev->pwr_domain->ops.complete)
|
||||
dev->pwr_domain->ops.complete(dev);
|
||||
if (dev->pm_domain->ops.complete)
|
||||
dev->pm_domain->ops.complete(dev);
|
||||
} else if (dev->type && dev->type->pm) {
|
||||
pm_dev_dbg(dev, state, "completing type ");
|
||||
if (dev->type->pm->complete)
|
||||
|
@ -744,9 +752,9 @@ static int device_suspend_noirq(struct device *dev, pm_message_t state)
|
|||
{
|
||||
int error;
|
||||
|
||||
if (dev->pwr_domain) {
|
||||
if (dev->pm_domain) {
|
||||
pm_dev_dbg(dev, state, "LATE power domain ");
|
||||
error = pm_noirq_op(dev, &dev->pwr_domain->ops, state);
|
||||
error = pm_noirq_op(dev, &dev->pm_domain->ops, state);
|
||||
if (error)
|
||||
return error;
|
||||
} else if (dev->type && dev->type->pm) {
|
||||
|
@ -843,19 +851,25 @@ static int __device_suspend(struct device *dev, pm_message_t state, bool async)
|
|||
int error = 0;
|
||||
|
||||
dpm_wait_for_children(dev, async);
|
||||
device_lock(dev);
|
||||
|
||||
if (async_error)
|
||||
goto Unlock;
|
||||
return 0;
|
||||
|
||||
pm_runtime_get_noresume(dev);
|
||||
if (pm_runtime_barrier(dev) && device_may_wakeup(dev))
|
||||
pm_wakeup_event(dev, 0);
|
||||
|
||||
if (pm_wakeup_pending()) {
|
||||
pm_runtime_put_sync(dev);
|
||||
async_error = -EBUSY;
|
||||
goto Unlock;
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (dev->pwr_domain) {
|
||||
device_lock(dev);
|
||||
|
||||
if (dev->pm_domain) {
|
||||
pm_dev_dbg(dev, state, "power domain ");
|
||||
error = pm_op(dev, &dev->pwr_domain->ops, state);
|
||||
error = pm_op(dev, &dev->pm_domain->ops, state);
|
||||
goto End;
|
||||
}
|
||||
|
||||
|
@ -890,12 +904,15 @@ static int __device_suspend(struct device *dev, pm_message_t state, bool async)
|
|||
End:
|
||||
dev->power.is_suspended = !error;
|
||||
|
||||
Unlock:
|
||||
device_unlock(dev);
|
||||
complete_all(&dev->power.completion);
|
||||
|
||||
if (error)
|
||||
if (error) {
|
||||
pm_runtime_put_sync(dev);
|
||||
async_error = error;
|
||||
} else if (dev->power.is_suspended) {
|
||||
__pm_runtime_disable(dev, false);
|
||||
}
|
||||
|
||||
return error;
|
||||
}
|
||||
|
@ -982,11 +999,11 @@ static int device_prepare(struct device *dev, pm_message_t state)
|
|||
|
||||
device_lock(dev);
|
||||
|
||||
if (dev->pwr_domain) {
|
||||
if (dev->pm_domain) {
|
||||
pm_dev_dbg(dev, state, "preparing power domain ");
|
||||
if (dev->pwr_domain->ops.prepare)
|
||||
error = dev->pwr_domain->ops.prepare(dev);
|
||||
suspend_report_result(dev->pwr_domain->ops.prepare, error);
|
||||
if (dev->pm_domain->ops.prepare)
|
||||
error = dev->pm_domain->ops.prepare(dev);
|
||||
suspend_report_result(dev->pm_domain->ops.prepare, error);
|
||||
if (error)
|
||||
goto End;
|
||||
} else if (dev->type && dev->type->pm) {
|
||||
|
@ -1035,13 +1052,7 @@ int dpm_prepare(pm_message_t state)
|
|||
get_device(dev);
|
||||
mutex_unlock(&dpm_list_mtx);
|
||||
|
||||
pm_runtime_get_noresume(dev);
|
||||
if (pm_runtime_barrier(dev) && device_may_wakeup(dev))
|
||||
pm_wakeup_event(dev, 0);
|
||||
|
||||
pm_runtime_put_sync(dev);
|
||||
error = pm_wakeup_pending() ?
|
||||
-EBUSY : device_prepare(dev, state);
|
||||
error = device_prepare(dev, state);
|
||||
|
||||
mutex_lock(&dpm_list_mtx);
|
||||
if (error) {
|
||||
|
|
|
@ -625,4 +625,21 @@ int opp_init_cpufreq_table(struct device *dev,
|
|||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* opp_free_cpufreq_table() - free the cpufreq table
|
||||
* @dev: device for which we do this operation
|
||||
* @table: table to free
|
||||
*
|
||||
* Free up the table allocated by opp_init_cpufreq_table
|
||||
*/
|
||||
void opp_free_cpufreq_table(struct device *dev,
|
||||
struct cpufreq_frequency_table **table)
|
||||
{
|
||||
if (!table)
|
||||
return;
|
||||
|
||||
kfree(*table);
|
||||
*table = NULL;
|
||||
}
|
||||
#endif /* CONFIG_CPU_FREQ */
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
* drivers/base/power/runtime.c - Helper functions for device run-time PM
|
||||
* drivers/base/power/runtime.c - Helper functions for device runtime PM
|
||||
*
|
||||
* Copyright (c) 2009 Rafael J. Wysocki <rjw@sisk.pl>, Novell Inc.
|
||||
* Copyright (C) 2010 Alan Stern <stern@rowland.harvard.edu>
|
||||
|
@ -135,8 +135,9 @@ static int rpm_check_suspend_allowed(struct device *dev)
|
|||
|
||||
if (dev->power.runtime_error)
|
||||
retval = -EINVAL;
|
||||
else if (atomic_read(&dev->power.usage_count) > 0
|
||||
|| dev->power.disable_depth > 0)
|
||||
else if (dev->power.disable_depth > 0)
|
||||
retval = -EACCES;
|
||||
else if (atomic_read(&dev->power.usage_count) > 0)
|
||||
retval = -EAGAIN;
|
||||
else if (!pm_children_suspended(dev))
|
||||
retval = -EBUSY;
|
||||
|
@ -158,7 +159,7 @@ static int rpm_check_suspend_allowed(struct device *dev)
|
|||
* @dev: Device to notify the bus type about.
|
||||
* @rpmflags: Flag bits.
|
||||
*
|
||||
* Check if the device's run-time PM status allows it to be suspended. If
|
||||
* Check if the device's runtime PM status allows it to be suspended. If
|
||||
* another idle notification has been started earlier, return immediately. If
|
||||
* the RPM_ASYNC flag is set then queue an idle-notification request; otherwise
|
||||
* run the ->runtime_idle() callback directly.
|
||||
|
@ -213,8 +214,8 @@ static int rpm_idle(struct device *dev, int rpmflags)
|
|||
|
||||
dev->power.idle_notification = true;
|
||||
|
||||
if (dev->pwr_domain)
|
||||
callback = dev->pwr_domain->ops.runtime_idle;
|
||||
if (dev->pm_domain)
|
||||
callback = dev->pm_domain->ops.runtime_idle;
|
||||
else if (dev->type && dev->type->pm)
|
||||
callback = dev->type->pm->runtime_idle;
|
||||
else if (dev->class && dev->class->pm)
|
||||
|
@ -262,15 +263,15 @@ static int rpm_callback(int (*cb)(struct device *), struct device *dev)
|
|||
spin_lock_irq(&dev->power.lock);
|
||||
}
|
||||
dev->power.runtime_error = retval;
|
||||
return retval;
|
||||
return retval != -EACCES ? retval : -EIO;
|
||||
}
|
||||
|
||||
/**
|
||||
* rpm_suspend - Carry out run-time suspend of given device.
|
||||
* rpm_suspend - Carry out runtime suspend of given device.
|
||||
* @dev: Device to suspend.
|
||||
* @rpmflags: Flag bits.
|
||||
*
|
||||
* Check if the device's run-time PM status allows it to be suspended. If
|
||||
* Check if the device's runtime PM status allows it to be suspended. If
|
||||
* another suspend has been started earlier, either return immediately or wait
|
||||
* for it to finish, depending on the RPM_NOWAIT and RPM_ASYNC flags. Cancel a
|
||||
* pending idle notification. If the RPM_ASYNC flag is set then queue a
|
||||
|
@ -374,8 +375,8 @@ static int rpm_suspend(struct device *dev, int rpmflags)
|
|||
|
||||
__update_runtime_status(dev, RPM_SUSPENDING);
|
||||
|
||||
if (dev->pwr_domain)
|
||||
callback = dev->pwr_domain->ops.runtime_suspend;
|
||||
if (dev->pm_domain)
|
||||
callback = dev->pm_domain->ops.runtime_suspend;
|
||||
else if (dev->type && dev->type->pm)
|
||||
callback = dev->type->pm->runtime_suspend;
|
||||
else if (dev->class && dev->class->pm)
|
||||
|
@ -388,7 +389,7 @@ static int rpm_suspend(struct device *dev, int rpmflags)
|
|||
retval = rpm_callback(callback, dev);
|
||||
if (retval) {
|
||||
__update_runtime_status(dev, RPM_ACTIVE);
|
||||
dev->power.deferred_resume = 0;
|
||||
dev->power.deferred_resume = false;
|
||||
if (retval == -EAGAIN || retval == -EBUSY)
|
||||
dev->power.runtime_error = 0;
|
||||
else
|
||||
|
@ -429,11 +430,11 @@ static int rpm_suspend(struct device *dev, int rpmflags)
|
|||
}
|
||||
|
||||
/**
|
||||
* rpm_resume - Carry out run-time resume of given device.
|
||||
* rpm_resume - Carry out runtime resume of given device.
|
||||
* @dev: Device to resume.
|
||||
* @rpmflags: Flag bits.
|
||||
*
|
||||
* Check if the device's run-time PM status allows it to be resumed. Cancel
|
||||
* Check if the device's runtime PM status allows it to be resumed. Cancel
|
||||
* any scheduled or pending requests. If another resume has been started
|
||||
* earlier, either return immediately or wait for it to finish, depending on the
|
||||
* RPM_NOWAIT and RPM_ASYNC flags. Similarly, if there's a suspend running in
|
||||
|
@ -458,7 +459,7 @@ static int rpm_resume(struct device *dev, int rpmflags)
|
|||
if (dev->power.runtime_error)
|
||||
retval = -EINVAL;
|
||||
else if (dev->power.disable_depth > 0)
|
||||
retval = -EAGAIN;
|
||||
retval = -EACCES;
|
||||
if (retval)
|
||||
goto out;
|
||||
|
||||
|
@ -550,7 +551,7 @@ static int rpm_resume(struct device *dev, int rpmflags)
|
|||
|
||||
spin_lock(&parent->power.lock);
|
||||
/*
|
||||
* We can resume if the parent's run-time PM is disabled or it
|
||||
* We can resume if the parent's runtime PM is disabled or it
|
||||
* is set to ignore children.
|
||||
*/
|
||||
if (!parent->power.disable_depth
|
||||
|
@ -573,8 +574,8 @@ static int rpm_resume(struct device *dev, int rpmflags)
|
|||
|
||||
__update_runtime_status(dev, RPM_RESUMING);
|
||||
|
||||
if (dev->pwr_domain)
|
||||
callback = dev->pwr_domain->ops.runtime_resume;
|
||||
if (dev->pm_domain)
|
||||
callback = dev->pm_domain->ops.runtime_resume;
|
||||
else if (dev->type && dev->type->pm)
|
||||
callback = dev->type->pm->runtime_resume;
|
||||
else if (dev->class && dev->class->pm)
|
||||
|
@ -614,11 +615,11 @@ static int rpm_resume(struct device *dev, int rpmflags)
|
|||
}
|
||||
|
||||
/**
|
||||
* pm_runtime_work - Universal run-time PM work function.
|
||||
* pm_runtime_work - Universal runtime PM work function.
|
||||
* @work: Work structure used for scheduling the execution of this function.
|
||||
*
|
||||
* Use @work to get the device object the work is to be done for, determine what
|
||||
* is to be done and execute the appropriate run-time PM function.
|
||||
* is to be done and execute the appropriate runtime PM function.
|
||||
*/
|
||||
static void pm_runtime_work(struct work_struct *work)
|
||||
{
|
||||
|
@ -717,7 +718,7 @@ int pm_schedule_suspend(struct device *dev, unsigned int delay)
|
|||
EXPORT_SYMBOL_GPL(pm_schedule_suspend);
|
||||
|
||||
/**
|
||||
* __pm_runtime_idle - Entry point for run-time idle operations.
|
||||
* __pm_runtime_idle - Entry point for runtime idle operations.
|
||||
* @dev: Device to send idle notification for.
|
||||
* @rpmflags: Flag bits.
|
||||
*
|
||||
|
@ -746,7 +747,7 @@ int __pm_runtime_idle(struct device *dev, int rpmflags)
|
|||
EXPORT_SYMBOL_GPL(__pm_runtime_idle);
|
||||
|
||||
/**
|
||||
* __pm_runtime_suspend - Entry point for run-time put/suspend operations.
|
||||
* __pm_runtime_suspend - Entry point for runtime put/suspend operations.
|
||||
* @dev: Device to suspend.
|
||||
* @rpmflags: Flag bits.
|
||||
*
|
||||
|
@ -775,7 +776,7 @@ int __pm_runtime_suspend(struct device *dev, int rpmflags)
|
|||
EXPORT_SYMBOL_GPL(__pm_runtime_suspend);
|
||||
|
||||
/**
|
||||
* __pm_runtime_resume - Entry point for run-time resume operations.
|
||||
* __pm_runtime_resume - Entry point for runtime resume operations.
|
||||
* @dev: Device to resume.
|
||||
* @rpmflags: Flag bits.
|
||||
*
|
||||
|
@ -801,11 +802,11 @@ int __pm_runtime_resume(struct device *dev, int rpmflags)
|
|||
EXPORT_SYMBOL_GPL(__pm_runtime_resume);
|
||||
|
||||
/**
|
||||
* __pm_runtime_set_status - Set run-time PM status of a device.
|
||||
* __pm_runtime_set_status - Set runtime PM status of a device.
|
||||
* @dev: Device to handle.
|
||||
* @status: New run-time PM status of the device.
|
||||
* @status: New runtime PM status of the device.
|
||||
*
|
||||
* If run-time PM of the device is disabled or its power.runtime_error field is
|
||||
* If runtime PM of the device is disabled or its power.runtime_error field is
|
||||
* different from zero, the status may be changed either to RPM_ACTIVE, or to
|
||||
* RPM_SUSPENDED, as long as that reflects the actual state of the device.
|
||||
* However, if the device has a parent and the parent is not active, and the
|
||||
|
@ -851,7 +852,7 @@ int __pm_runtime_set_status(struct device *dev, unsigned int status)
|
|||
|
||||
/*
|
||||
* It is invalid to put an active child under a parent that is
|
||||
* not active, has run-time PM enabled and the
|
||||
* not active, has runtime PM enabled and the
|
||||
* 'power.ignore_children' flag unset.
|
||||
*/
|
||||
if (!parent->power.disable_depth
|
||||
|
@ -885,7 +886,7 @@ EXPORT_SYMBOL_GPL(__pm_runtime_set_status);
|
|||
* @dev: Device to handle.
|
||||
*
|
||||
* Flush all pending requests for the device from pm_wq and wait for all
|
||||
* run-time PM operations involving the device in progress to complete.
|
||||
* runtime PM operations involving the device in progress to complete.
|
||||
*
|
||||
* Should be called under dev->power.lock with interrupts disabled.
|
||||
*/
|
||||
|
@ -933,7 +934,7 @@ static void __pm_runtime_barrier(struct device *dev)
|
|||
* Prevent the device from being suspended by incrementing its usage counter and
|
||||
* if there's a pending resume request for the device, wake the device up.
|
||||
* Next, make sure that all pending requests for the device have been flushed
|
||||
* from pm_wq and wait for all run-time PM operations involving the device in
|
||||
* from pm_wq and wait for all runtime PM operations involving the device in
|
||||
* progress to complete.
|
||||
*
|
||||
* Return value:
|
||||
|
@ -963,18 +964,18 @@ int pm_runtime_barrier(struct device *dev)
|
|||
EXPORT_SYMBOL_GPL(pm_runtime_barrier);
|
||||
|
||||
/**
|
||||
* __pm_runtime_disable - Disable run-time PM of a device.
|
||||
* __pm_runtime_disable - Disable runtime PM of a device.
|
||||
* @dev: Device to handle.
|
||||
* @check_resume: If set, check if there's a resume request for the device.
|
||||
*
|
||||
* Increment power.disable_depth for the device and if was zero previously,
|
||||
* cancel all pending run-time PM requests for the device and wait for all
|
||||
* cancel all pending runtime PM requests for the device and wait for all
|
||||
* operations in progress to complete. The device can be either active or
|
||||
* suspended after its run-time PM has been disabled.
|
||||
* suspended after its runtime PM has been disabled.
|
||||
*
|
||||
* If @check_resume is set and there's a resume request pending when
|
||||
* __pm_runtime_disable() is called and power.disable_depth is zero, the
|
||||
* function will wake up the device before disabling its run-time PM.
|
||||
* function will wake up the device before disabling its runtime PM.
|
||||
*/
|
||||
void __pm_runtime_disable(struct device *dev, bool check_resume)
|
||||
{
|
||||
|
@ -987,7 +988,7 @@ void __pm_runtime_disable(struct device *dev, bool check_resume)
|
|||
|
||||
/*
|
||||
* Wake up the device if there's a resume request pending, because that
|
||||
* means there probably is some I/O to process and disabling run-time PM
|
||||
* means there probably is some I/O to process and disabling runtime PM
|
||||
* shouldn't prevent the device from processing the I/O.
|
||||
*/
|
||||
if (check_resume && dev->power.request_pending
|
||||
|
@ -1012,7 +1013,7 @@ void __pm_runtime_disable(struct device *dev, bool check_resume)
|
|||
EXPORT_SYMBOL_GPL(__pm_runtime_disable);
|
||||
|
||||
/**
|
||||
* pm_runtime_enable - Enable run-time PM of a device.
|
||||
* pm_runtime_enable - Enable runtime PM of a device.
|
||||
* @dev: Device to handle.
|
||||
*/
|
||||
void pm_runtime_enable(struct device *dev)
|
||||
|
@ -1031,7 +1032,7 @@ void pm_runtime_enable(struct device *dev)
|
|||
EXPORT_SYMBOL_GPL(pm_runtime_enable);
|
||||
|
||||
/**
|
||||
* pm_runtime_forbid - Block run-time PM of a device.
|
||||
* pm_runtime_forbid - Block runtime PM of a device.
|
||||
* @dev: Device to handle.
|
||||
*
|
||||
* Increase the device's usage count and clear its power.runtime_auto flag,
|
||||
|
@ -1054,7 +1055,7 @@ void pm_runtime_forbid(struct device *dev)
|
|||
EXPORT_SYMBOL_GPL(pm_runtime_forbid);
|
||||
|
||||
/**
|
||||
* pm_runtime_allow - Unblock run-time PM of a device.
|
||||
* pm_runtime_allow - Unblock runtime PM of a device.
|
||||
* @dev: Device to handle.
|
||||
*
|
||||
* Decrease the device's usage count and set its power.runtime_auto flag.
|
||||
|
@ -1075,12 +1076,12 @@ void pm_runtime_allow(struct device *dev)
|
|||
EXPORT_SYMBOL_GPL(pm_runtime_allow);
|
||||
|
||||
/**
|
||||
* pm_runtime_no_callbacks - Ignore run-time PM callbacks for a device.
|
||||
* pm_runtime_no_callbacks - Ignore runtime PM callbacks for a device.
|
||||
* @dev: Device to handle.
|
||||
*
|
||||
* Set the power.no_callbacks flag, which tells the PM core that this
|
||||
* device is power-managed through its parent and has no run-time PM
|
||||
* callbacks of its own. The run-time sysfs attributes will be removed.
|
||||
* device is power-managed through its parent and has no runtime PM
|
||||
* callbacks of its own. The runtime sysfs attributes will be removed.
|
||||
*/
|
||||
void pm_runtime_no_callbacks(struct device *dev)
|
||||
{
|
||||
|
@ -1156,8 +1157,8 @@ static void update_autosuspend(struct device *dev, int old_delay, int old_use)
|
|||
* @delay: Value of the new delay in milliseconds.
|
||||
*
|
||||
* Set the device's power.autosuspend_delay value. If it changes to negative
|
||||
* and the power.use_autosuspend flag is set, prevent run-time suspends. If it
|
||||
* changes the other way, allow run-time suspends.
|
||||
* and the power.use_autosuspend flag is set, prevent runtime suspends. If it
|
||||
* changes the other way, allow runtime suspends.
|
||||
*/
|
||||
void pm_runtime_set_autosuspend_delay(struct device *dev, int delay)
|
||||
{
|
||||
|
@ -1177,7 +1178,7 @@ EXPORT_SYMBOL_GPL(pm_runtime_set_autosuspend_delay);
|
|||
* @dev: Device to handle.
|
||||
* @use: New value for use_autosuspend.
|
||||
*
|
||||
* Set the device's power.use_autosuspend flag, and allow or prevent run-time
|
||||
* Set the device's power.use_autosuspend flag, and allow or prevent runtime
|
||||
* suspends as needed.
|
||||
*/
|
||||
void __pm_runtime_use_autosuspend(struct device *dev, bool use)
|
||||
|
@ -1194,7 +1195,7 @@ void __pm_runtime_use_autosuspend(struct device *dev, bool use)
|
|||
EXPORT_SYMBOL_GPL(__pm_runtime_use_autosuspend);
|
||||
|
||||
/**
|
||||
* pm_runtime_init - Initialize run-time PM fields in given device object.
|
||||
* pm_runtime_init - Initialize runtime PM fields in given device object.
|
||||
* @dev: Device object to initialize.
|
||||
*/
|
||||
void pm_runtime_init(struct device *dev)
|
||||
|
|
|
@ -116,12 +116,14 @@ static ssize_t control_store(struct device * dev, struct device_attribute *attr,
|
|||
cp = memchr(buf, '\n', n);
|
||||
if (cp)
|
||||
len = cp - buf;
|
||||
device_lock(dev);
|
||||
if (len == sizeof ctrl_auto - 1 && strncmp(buf, ctrl_auto, len) == 0)
|
||||
pm_runtime_allow(dev);
|
||||
else if (len == sizeof ctrl_on - 1 && strncmp(buf, ctrl_on, len) == 0)
|
||||
pm_runtime_forbid(dev);
|
||||
else
|
||||
return -EINVAL;
|
||||
n = -EINVAL;
|
||||
device_unlock(dev);
|
||||
return n;
|
||||
}
|
||||
|
||||
|
@ -205,7 +207,9 @@ static ssize_t autosuspend_delay_ms_store(struct device *dev,
|
|||
if (strict_strtol(buf, 10, &delay) != 0 || delay != (int) delay)
|
||||
return -EINVAL;
|
||||
|
||||
device_lock(dev);
|
||||
pm_runtime_set_autosuspend_delay(dev, delay);
|
||||
device_unlock(dev);
|
||||
return n;
|
||||
}
|
||||
|
||||
|
|
|
@ -112,7 +112,7 @@ static unsigned int read_magic_time(void)
|
|||
unsigned int val;
|
||||
|
||||
get_rtc_time(&time);
|
||||
pr_info("Time: %2d:%02d:%02d Date: %02d/%02d/%02d\n",
|
||||
pr_info("RTC time: %2d:%02d:%02d, date: %02d/%02d/%02d\n",
|
||||
time.tm_hour, time.tm_min, time.tm_sec,
|
||||
time.tm_mon + 1, time.tm_mday, time.tm_year % 100);
|
||||
val = time.tm_year; /* 100 years */
|
||||
|
|
|
@ -606,7 +606,7 @@ static int apm_suspend_notifier(struct notifier_block *nb,
|
|||
return NOTIFY_OK;
|
||||
|
||||
/* interrupted by signal */
|
||||
return NOTIFY_BAD;
|
||||
return notifier_from_errno(err);
|
||||
|
||||
case PM_POST_SUSPEND:
|
||||
/*
|
||||
|
|
|
@ -18,6 +18,7 @@
|
|||
#include <linux/sched.h>
|
||||
#include <linux/cpu.h>
|
||||
#include <linux/pm_runtime.h>
|
||||
#include <linux/suspend.h>
|
||||
#include "pci.h"
|
||||
|
||||
struct pci_dynid {
|
||||
|
@ -615,6 +616,21 @@ static int pci_pm_prepare(struct device *dev)
|
|||
struct device_driver *drv = dev->driver;
|
||||
int error = 0;
|
||||
|
||||
/*
|
||||
* If a PCI device configured to wake up the system from sleep states
|
||||
* has been suspended at run time and there's a resume request pending
|
||||
* for it, this is equivalent to the device signaling wakeup, so the
|
||||
* system suspend operation should be aborted.
|
||||
*/
|
||||
pm_runtime_get_noresume(dev);
|
||||
if (pm_runtime_barrier(dev) && device_may_wakeup(dev))
|
||||
pm_wakeup_event(dev, 0);
|
||||
|
||||
if (pm_wakeup_pending()) {
|
||||
pm_runtime_put_sync(dev);
|
||||
return -EBUSY;
|
||||
}
|
||||
|
||||
/*
|
||||
* PCI devices suspended at run time need to be resumed at this
|
||||
* point, because in general it is necessary to reconfigure them for
|
||||
|
@ -624,7 +640,7 @@ static int pci_pm_prepare(struct device *dev)
|
|||
* system from the sleep state, we'll have to prevent it from signaling
|
||||
* wake-up.
|
||||
*/
|
||||
pm_runtime_get_sync(dev);
|
||||
pm_runtime_resume(dev);
|
||||
|
||||
if (drv && drv->pm && drv->pm->prepare)
|
||||
error = drv->pm->prepare(dev);
|
||||
|
|
|
@ -258,13 +258,13 @@ static int vmwdt_suspend(void)
|
|||
if (test_and_set_bit(VMWDT_OPEN, &vmwdt_is_open)) {
|
||||
pr_err("The system cannot be suspended while the watchdog"
|
||||
" is in use\n");
|
||||
return NOTIFY_BAD;
|
||||
return notifier_from_errno(-EBUSY);
|
||||
}
|
||||
if (test_bit(VMWDT_RUNNING, &vmwdt_is_open)) {
|
||||
clear_bit(VMWDT_OPEN, &vmwdt_is_open);
|
||||
pr_err("The system cannot be suspended while the watchdog"
|
||||
" is running\n");
|
||||
return NOTIFY_BAD;
|
||||
return notifier_from_errno(-EBUSY);
|
||||
}
|
||||
return NOTIFY_DONE;
|
||||
}
|
||||
|
|
|
@ -814,8 +814,8 @@ static int css_power_event(struct notifier_block *this, unsigned long event,
|
|||
mutex_unlock(&css->mutex);
|
||||
continue;
|
||||
}
|
||||
if (__chsc_do_secm(css, 0))
|
||||
ret = NOTIFY_BAD;
|
||||
ret = __chsc_do_secm(css, 0);
|
||||
ret = notifier_from_errno(ret);
|
||||
mutex_unlock(&css->mutex);
|
||||
}
|
||||
break;
|
||||
|
@ -831,8 +831,8 @@ static int css_power_event(struct notifier_block *this, unsigned long event,
|
|||
mutex_unlock(&css->mutex);
|
||||
continue;
|
||||
}
|
||||
if (__chsc_do_secm(css, 1))
|
||||
ret = NOTIFY_BAD;
|
||||
ret = __chsc_do_secm(css, 1);
|
||||
ret = notifier_from_errno(ret);
|
||||
mutex_unlock(&css->mutex);
|
||||
}
|
||||
/* search for subchannels, which appeared during hibernation */
|
||||
|
|
|
@ -144,9 +144,9 @@ int scsi_autopm_get_device(struct scsi_device *sdev)
|
|||
int err;
|
||||
|
||||
err = pm_runtime_get_sync(&sdev->sdev_gendev);
|
||||
if (err < 0)
|
||||
if (err < 0 && err !=-EACCES)
|
||||
pm_runtime_put_sync(&sdev->sdev_gendev);
|
||||
else if (err > 0)
|
||||
else
|
||||
err = 0;
|
||||
return err;
|
||||
}
|
||||
|
@ -173,9 +173,9 @@ int scsi_autopm_get_host(struct Scsi_Host *shost)
|
|||
int err;
|
||||
|
||||
err = pm_runtime_get_sync(&shost->shost_gendev);
|
||||
if (err < 0)
|
||||
if (err < 0 && err !=-EACCES)
|
||||
pm_runtime_put_sync(&shost->shost_gendev);
|
||||
else if (err > 0)
|
||||
else
|
||||
err = 0;
|
||||
return err;
|
||||
}
|
||||
|
|
|
@ -516,7 +516,7 @@ struct device_dma_parameters {
|
|||
* minimizes board-specific #ifdefs in drivers.
|
||||
* @power: For device power management.
|
||||
* See Documentation/power/devices.txt for details.
|
||||
* @pwr_domain: Provide callbacks that are executed during system suspend,
|
||||
* @pm_domain: Provide callbacks that are executed during system suspend,
|
||||
* hibernation, system resume and during runtime PM transitions
|
||||
* along with subsystem-level and driver-level callbacks.
|
||||
* @numa_node: NUMA node this device is close to.
|
||||
|
@ -567,7 +567,7 @@ struct device {
|
|||
void *platform_data; /* Platform specific data, device
|
||||
core doesn't touch it */
|
||||
struct dev_pm_info power;
|
||||
struct dev_power_domain *pwr_domain;
|
||||
struct dev_pm_domain *pm_domain;
|
||||
|
||||
#ifdef CONFIG_NUMA
|
||||
int numa_node; /* NUMA node this device is close to */
|
||||
|
|
|
@ -94,12 +94,20 @@ static inline int opp_disable(struct device *dev, unsigned long freq)
|
|||
#if defined(CONFIG_CPU_FREQ) && defined(CONFIG_PM_OPP)
|
||||
int opp_init_cpufreq_table(struct device *dev,
|
||||
struct cpufreq_frequency_table **table);
|
||||
void opp_free_cpufreq_table(struct device *dev,
|
||||
struct cpufreq_frequency_table **table);
|
||||
#else
|
||||
static inline int opp_init_cpufreq_table(struct device *dev,
|
||||
struct cpufreq_frequency_table **table)
|
||||
{
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
static inline
|
||||
void opp_free_cpufreq_table(struct device *dev,
|
||||
struct cpufreq_frequency_table **table)
|
||||
{
|
||||
}
|
||||
#endif /* CONFIG_CPU_FREQ */
|
||||
|
||||
#endif /* __LINUX_OPP_H__ */
|
||||
|
|
|
@ -461,8 +461,8 @@ struct dev_pm_info {
|
|||
unsigned long active_jiffies;
|
||||
unsigned long suspended_jiffies;
|
||||
unsigned long accounting_timestamp;
|
||||
void *subsys_data; /* Owned by the subsystem. */
|
||||
#endif
|
||||
void *subsys_data; /* Owned by the subsystem. */
|
||||
};
|
||||
|
||||
extern void update_pm_runtime_accounting(struct device *dev);
|
||||
|
@ -472,7 +472,7 @@ extern void update_pm_runtime_accounting(struct device *dev);
|
|||
* hibernation, system resume and during runtime PM transitions along with
|
||||
* subsystem-level and driver-level callbacks.
|
||||
*/
|
||||
struct dev_power_domain {
|
||||
struct dev_pm_domain {
|
||||
struct dev_pm_ops ops;
|
||||
};
|
||||
|
||||
|
@ -553,11 +553,17 @@ extern void __suspend_report_result(const char *function, void *fn, int ret);
|
|||
extern int device_pm_wait_for_dev(struct device *sub, struct device *dev);
|
||||
|
||||
extern int pm_generic_prepare(struct device *dev);
|
||||
extern int pm_generic_suspend_noirq(struct device *dev);
|
||||
extern int pm_generic_suspend(struct device *dev);
|
||||
extern int pm_generic_resume_noirq(struct device *dev);
|
||||
extern int pm_generic_resume(struct device *dev);
|
||||
extern int pm_generic_freeze_noirq(struct device *dev);
|
||||
extern int pm_generic_freeze(struct device *dev);
|
||||
extern int pm_generic_thaw_noirq(struct device *dev);
|
||||
extern int pm_generic_thaw(struct device *dev);
|
||||
extern int pm_generic_restore_noirq(struct device *dev);
|
||||
extern int pm_generic_restore(struct device *dev);
|
||||
extern int pm_generic_poweroff_noirq(struct device *dev);
|
||||
extern int pm_generic_poweroff(struct device *dev);
|
||||
extern void pm_generic_complete(struct device *dev);
|
||||
|
||||
|
|
108
include/linux/pm_domain.h
Normal file
108
include/linux/pm_domain.h
Normal file
|
@ -0,0 +1,108 @@
|
|||
/*
|
||||
* pm_domain.h - Definitions and headers related to device power domains.
|
||||
*
|
||||
* Copyright (C) 2011 Rafael J. Wysocki <rjw@sisk.pl>, Renesas Electronics Corp.
|
||||
*
|
||||
* This file is released under the GPLv2.
|
||||
*/
|
||||
|
||||
#ifndef _LINUX_PM_DOMAIN_H
|
||||
#define _LINUX_PM_DOMAIN_H
|
||||
|
||||
#include <linux/device.h>
|
||||
|
||||
enum gpd_status {
|
||||
GPD_STATE_ACTIVE = 0, /* PM domain is active */
|
||||
GPD_STATE_BUSY, /* Something is happening to the PM domain */
|
||||
GPD_STATE_REPEAT, /* Power off in progress, to be repeated */
|
||||
GPD_STATE_POWER_OFF, /* PM domain is off */
|
||||
};
|
||||
|
||||
struct dev_power_governor {
|
||||
bool (*power_down_ok)(struct dev_pm_domain *domain);
|
||||
};
|
||||
|
||||
struct generic_pm_domain {
|
||||
struct dev_pm_domain domain; /* PM domain operations */
|
||||
struct list_head gpd_list_node; /* Node in the global PM domains list */
|
||||
struct list_head sd_node; /* Node in the parent's subdomain list */
|
||||
struct generic_pm_domain *parent; /* Parent PM domain */
|
||||
struct list_head sd_list; /* List of dubdomains */
|
||||
struct list_head dev_list; /* List of devices */
|
||||
struct mutex lock;
|
||||
struct dev_power_governor *gov;
|
||||
struct work_struct power_off_work;
|
||||
unsigned int in_progress; /* Number of devices being suspended now */
|
||||
unsigned int sd_count; /* Number of subdomains with power "on" */
|
||||
enum gpd_status status; /* Current state of the domain */
|
||||
wait_queue_head_t status_wait_queue;
|
||||
struct task_struct *poweroff_task; /* Powering off task */
|
||||
unsigned int resume_count; /* Number of devices being resumed */
|
||||
unsigned int device_count; /* Number of devices */
|
||||
unsigned int suspended_count; /* System suspend device counter */
|
||||
unsigned int prepared_count; /* Suspend counter of prepared devices */
|
||||
bool suspend_power_off; /* Power status before system suspend */
|
||||
int (*power_off)(struct generic_pm_domain *domain);
|
||||
int (*power_on)(struct generic_pm_domain *domain);
|
||||
int (*start_device)(struct device *dev);
|
||||
int (*stop_device)(struct device *dev);
|
||||
bool (*active_wakeup)(struct device *dev);
|
||||
};
|
||||
|
||||
static inline struct generic_pm_domain *pd_to_genpd(struct dev_pm_domain *pd)
|
||||
{
|
||||
return container_of(pd, struct generic_pm_domain, domain);
|
||||
}
|
||||
|
||||
struct dev_list_entry {
|
||||
struct list_head node;
|
||||
struct device *dev;
|
||||
bool need_restore;
|
||||
};
|
||||
|
||||
#ifdef CONFIG_PM_GENERIC_DOMAINS
|
||||
extern int pm_genpd_add_device(struct generic_pm_domain *genpd,
|
||||
struct device *dev);
|
||||
extern int pm_genpd_remove_device(struct generic_pm_domain *genpd,
|
||||
struct device *dev);
|
||||
extern int pm_genpd_add_subdomain(struct generic_pm_domain *genpd,
|
||||
struct generic_pm_domain *new_subdomain);
|
||||
extern int pm_genpd_remove_subdomain(struct generic_pm_domain *genpd,
|
||||
struct generic_pm_domain *target);
|
||||
extern void pm_genpd_init(struct generic_pm_domain *genpd,
|
||||
struct dev_power_governor *gov, bool is_off);
|
||||
extern int pm_genpd_poweron(struct generic_pm_domain *genpd);
|
||||
extern void pm_genpd_poweroff_unused(void);
|
||||
extern void genpd_queue_power_off_work(struct generic_pm_domain *genpd);
|
||||
#else
|
||||
static inline int pm_genpd_add_device(struct generic_pm_domain *genpd,
|
||||
struct device *dev)
|
||||
{
|
||||
return -ENOSYS;
|
||||
}
|
||||
static inline int pm_genpd_remove_device(struct generic_pm_domain *genpd,
|
||||
struct device *dev)
|
||||
{
|
||||
return -ENOSYS;
|
||||
}
|
||||
static inline int pm_genpd_add_subdomain(struct generic_pm_domain *genpd,
|
||||
struct generic_pm_domain *new_sd)
|
||||
{
|
||||
return -ENOSYS;
|
||||
}
|
||||
static inline int pm_genpd_remove_subdomain(struct generic_pm_domain *genpd,
|
||||
struct generic_pm_domain *target)
|
||||
{
|
||||
return -ENOSYS;
|
||||
}
|
||||
static inline void pm_genpd_init(struct generic_pm_domain *genpd,
|
||||
struct dev_power_governor *gov, bool is_off) {}
|
||||
static inline int pm_genpd_poweron(struct generic_pm_domain *genpd)
|
||||
{
|
||||
return -ENOSYS;
|
||||
}
|
||||
static inline void pm_genpd_poweroff_unused(void) {}
|
||||
static inline void genpd_queue_power_off_work(struct generic_pm_domain *gpd) {}
|
||||
#endif
|
||||
|
||||
#endif /* _LINUX_PM_DOMAIN_H */
|
|
@ -82,6 +82,11 @@ static inline bool pm_runtime_suspended(struct device *dev)
|
|||
&& !dev->power.disable_depth;
|
||||
}
|
||||
|
||||
static inline bool pm_runtime_status_suspended(struct device *dev)
|
||||
{
|
||||
return dev->power.runtime_status == RPM_SUSPENDED;
|
||||
}
|
||||
|
||||
static inline bool pm_runtime_enabled(struct device *dev)
|
||||
{
|
||||
return !dev->power.disable_depth;
|
||||
|
@ -130,6 +135,7 @@ static inline void pm_runtime_put_noidle(struct device *dev) {}
|
|||
static inline bool device_run_wake(struct device *dev) { return false; }
|
||||
static inline void device_set_run_wake(struct device *dev, bool enable) {}
|
||||
static inline bool pm_runtime_suspended(struct device *dev) { return false; }
|
||||
static inline bool pm_runtime_status_suspended(struct device *dev) { return false; }
|
||||
static inline bool pm_runtime_enabled(struct device *dev) { return false; }
|
||||
|
||||
static inline int pm_generic_runtime_idle(struct device *dev) { return 0; }
|
||||
|
@ -247,41 +253,41 @@ static inline void pm_runtime_dont_use_autosuspend(struct device *dev)
|
|||
|
||||
struct pm_clk_notifier_block {
|
||||
struct notifier_block nb;
|
||||
struct dev_power_domain *pwr_domain;
|
||||
struct dev_pm_domain *pm_domain;
|
||||
char *con_ids[];
|
||||
};
|
||||
|
||||
#ifdef CONFIG_PM_RUNTIME_CLK
|
||||
extern int pm_runtime_clk_init(struct device *dev);
|
||||
extern void pm_runtime_clk_destroy(struct device *dev);
|
||||
extern int pm_runtime_clk_add(struct device *dev, const char *con_id);
|
||||
extern void pm_runtime_clk_remove(struct device *dev, const char *con_id);
|
||||
extern int pm_runtime_clk_suspend(struct device *dev);
|
||||
extern int pm_runtime_clk_resume(struct device *dev);
|
||||
#ifdef CONFIG_PM_CLK
|
||||
extern int pm_clk_init(struct device *dev);
|
||||
extern void pm_clk_destroy(struct device *dev);
|
||||
extern int pm_clk_add(struct device *dev, const char *con_id);
|
||||
extern void pm_clk_remove(struct device *dev, const char *con_id);
|
||||
extern int pm_clk_suspend(struct device *dev);
|
||||
extern int pm_clk_resume(struct device *dev);
|
||||
#else
|
||||
static inline int pm_runtime_clk_init(struct device *dev)
|
||||
static inline int pm_clk_init(struct device *dev)
|
||||
{
|
||||
return -EINVAL;
|
||||
}
|
||||
static inline void pm_runtime_clk_destroy(struct device *dev)
|
||||
static inline void pm_clk_destroy(struct device *dev)
|
||||
{
|
||||
}
|
||||
static inline int pm_runtime_clk_add(struct device *dev, const char *con_id)
|
||||
static inline int pm_clk_add(struct device *dev, const char *con_id)
|
||||
{
|
||||
return -EINVAL;
|
||||
}
|
||||
static inline void pm_runtime_clk_remove(struct device *dev, const char *con_id)
|
||||
static inline void pm_clk_remove(struct device *dev, const char *con_id)
|
||||
{
|
||||
}
|
||||
#define pm_runtime_clock_suspend NULL
|
||||
#define pm_runtime_clock_resume NULL
|
||||
#define pm_clk_suspend NULL
|
||||
#define pm_clk_resume NULL
|
||||
#endif
|
||||
|
||||
#ifdef CONFIG_HAVE_CLK
|
||||
extern void pm_runtime_clk_add_notifier(struct bus_type *bus,
|
||||
extern void pm_clk_add_notifier(struct bus_type *bus,
|
||||
struct pm_clk_notifier_block *clknb);
|
||||
#else
|
||||
static inline void pm_runtime_clk_add_notifier(struct bus_type *bus,
|
||||
static inline void pm_clk_add_notifier(struct bus_type *bus,
|
||||
struct pm_clk_notifier_block *clknb)
|
||||
{
|
||||
}
|
||||
|
|
|
@ -92,6 +92,13 @@ typedef int __bitwise suspend_state_t;
|
|||
* @enter() and @wake(), even if any of them fails. It is executed after
|
||||
* a failing @prepare.
|
||||
*
|
||||
* @suspend_again: Returns whether the system should suspend again (true) or
|
||||
* not (false). If the platform wants to poll sensors or execute some
|
||||
* code during suspended without invoking userspace and most of devices,
|
||||
* suspend_again callback is the place assuming that periodic-wakeup or
|
||||
* alarm-wakeup is already setup. This allows to execute some codes while
|
||||
* being kept suspended in the view of userland and devices.
|
||||
*
|
||||
* @end: Called by the PM core right after resuming devices, to indicate to
|
||||
* the platform that the system has returned to the working state or
|
||||
* the transition to the sleep state has been aborted.
|
||||
|
@ -113,6 +120,7 @@ struct platform_suspend_ops {
|
|||
int (*enter)(suspend_state_t state);
|
||||
void (*wake)(void);
|
||||
void (*finish)(void);
|
||||
bool (*suspend_again)(void);
|
||||
void (*end)(void);
|
||||
void (*recover)(void);
|
||||
};
|
||||
|
|
|
@ -224,6 +224,10 @@ config PM_OPP
|
|||
implementations a ready to use framework to manage OPPs.
|
||||
For more information, read <file:Documentation/power/opp.txt>
|
||||
|
||||
config PM_RUNTIME_CLK
|
||||
config PM_CLK
|
||||
def_bool y
|
||||
depends on PM_RUNTIME && HAVE_CLK
|
||||
depends on PM && HAVE_CLK
|
||||
|
||||
config PM_GENERIC_DOMAINS
|
||||
bool
|
||||
depends on PM
|
||||
|
|
|
@ -37,8 +37,9 @@ EXPORT_SYMBOL_GPL(unregister_pm_notifier);
|
|||
|
||||
int pm_notifier_call_chain(unsigned long val)
|
||||
{
|
||||
return (blocking_notifier_call_chain(&pm_chain_head, val, NULL)
|
||||
== NOTIFY_BAD) ? -EINVAL : 0;
|
||||
int ret = blocking_notifier_call_chain(&pm_chain_head, val, NULL);
|
||||
|
||||
return notifier_to_errno(ret);
|
||||
}
|
||||
|
||||
/* If set, devices may be suspended and resumed asynchronously. */
|
||||
|
|
|
@ -44,6 +44,7 @@ void suspend_set_ops(const struct platform_suspend_ops *ops)
|
|||
suspend_ops = ops;
|
||||
mutex_unlock(&pm_mutex);
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(suspend_set_ops);
|
||||
|
||||
bool valid_state(suspend_state_t state)
|
||||
{
|
||||
|
@ -65,6 +66,7 @@ int suspend_valid_only_mem(suspend_state_t state)
|
|||
{
|
||||
return state == PM_SUSPEND_MEM;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(suspend_valid_only_mem);
|
||||
|
||||
static int suspend_test(int level)
|
||||
{
|
||||
|
@ -126,12 +128,13 @@ void __attribute__ ((weak)) arch_suspend_enable_irqs(void)
|
|||
}
|
||||
|
||||
/**
|
||||
* suspend_enter - enter the desired system sleep state.
|
||||
* @state: state to enter
|
||||
* suspend_enter - enter the desired system sleep state.
|
||||
* @state: State to enter
|
||||
* @wakeup: Returns information that suspend should not be entered again.
|
||||
*
|
||||
* This function should be called after devices have been suspended.
|
||||
* This function should be called after devices have been suspended.
|
||||
*/
|
||||
static int suspend_enter(suspend_state_t state)
|
||||
static int suspend_enter(suspend_state_t state, bool *wakeup)
|
||||
{
|
||||
int error;
|
||||
|
||||
|
@ -165,7 +168,8 @@ static int suspend_enter(suspend_state_t state)
|
|||
|
||||
error = syscore_suspend();
|
||||
if (!error) {
|
||||
if (!(suspend_test(TEST_CORE) || pm_wakeup_pending())) {
|
||||
*wakeup = pm_wakeup_pending();
|
||||
if (!(suspend_test(TEST_CORE) || *wakeup)) {
|
||||
error = suspend_ops->enter(state);
|
||||
events_check_enabled = false;
|
||||
}
|
||||
|
@ -199,6 +203,7 @@ static int suspend_enter(suspend_state_t state)
|
|||
int suspend_devices_and_enter(suspend_state_t state)
|
||||
{
|
||||
int error;
|
||||
bool wakeup = false;
|
||||
|
||||
if (!suspend_ops)
|
||||
return -ENOSYS;
|
||||
|
@ -220,7 +225,10 @@ int suspend_devices_and_enter(suspend_state_t state)
|
|||
if (suspend_test(TEST_DEVICES))
|
||||
goto Recover_platform;
|
||||
|
||||
error = suspend_enter(state);
|
||||
do {
|
||||
error = suspend_enter(state, &wakeup);
|
||||
} while (!error && !wakeup
|
||||
&& suspend_ops->suspend_again && suspend_ops->suspend_again());
|
||||
|
||||
Resume_devices:
|
||||
suspend_test_start();
|
||||
|
|
Loading…
Reference in a new issue