hollalinux
/
linux-sg2042
mirror of https://github.com/sophgo/linux-riscv.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

PM: Rename clock management functions 

The common PM clock management functions may be used for system
suspend/resume as well as for runtime PM, so rename them
accordingly.  Modify kerneldoc comments describing these functions
and kernel messages printed by them, so that they refer to power
management in general rather that to runtime PM.

Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
Reviewed-by: Kevin Hilman <khilman@ti.com>
This commit is contained in:
Rafael J. Wysocki 2011-07-01 22:13:44 +02:00
parent b7b95920aa
commit 3d5c30367c
4 changed files with 114 additions and 114 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
arch/arm/mach-omap1/pm_bus.c
View File

@ -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,7 +45,7 @@ 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);
}
@ -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;
}

6
arch/arm/mach-shmobile/pm_runtime.c
View File

@ -30,8 +30,8 @@ static int default_platform_runtime_idle(struct device *dev)
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
},
@ -52,7 +52,7 @@ static struct pm_clk_notifier_block platform_bus_notifier = {
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);

188
drivers/base/power/clock_ops.c
View File

@ -17,7 +17,7 @@
#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,87 +108,87 @@ 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 */
@ -196,11 +196,11 @@ void pm_runtime_clk_destroy(struct device *dev)
#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);
@ -213,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);
@ -238,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);
@ -269,13 +269,13 @@ 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.
@ -284,13 +284,13 @@ int pm_runtime_clk_resume(struct device *dev)
* struct pm_clk_notifier_block containing all of the requisite data.
* 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 runtime PM clocks, depending on @action.
* of PM clocks, depending on @action.
*
* 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;
@ -307,16 +307,16 @@ static int pm_runtime_clk_notify(struct notifier_block *nb,
if (dev->pm_domain)
break;
error = pm_runtime_clk_init(dev);
error = pm_clk_init(dev);
if (error)
break;
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;
@ -325,7 +325,7 @@ static int pm_runtime_clk_notify(struct notifier_block *nb,
break;
dev->pm_domain = NULL;
pm_runtime_clk_destroy(dev);
pm_clk_destroy(dev);
break;
}
@ -337,51 +337,51 @@ static int pm_runtime_clk_notify(struct notifier_block *nb,
#ifdef CONFIG_PM
/**
* pm_runtime_clk_suspend - Disable clocks in a device's 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 there is no driver, the clocks are already disabled. */
if (!prd || !dev->driver)
if (!pcd || !dev->driver)
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)
clk_disable(ce->clk);
mutex_unlock(&prd->lock);
mutex_unlock(&pcd->lock);
return 0;
}
/**
* pm_runtime_clk_resume - Enable clocks in a device's 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 there is no driver, the clocks should remain disabled. */
if (!prd || !dev->driver)
if (!pcd || !dev->driver)
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)
clk_enable(ce->clk);
mutex_unlock(&prd->lock);
mutex_unlock(&pcd->lock);
return 0;
}
@ -423,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.
@ -433,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;
@ -469,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);
}

28
include/linux/pm_runtime.h
View File

@ -252,36 +252,36 @@ struct pm_clk_notifier_block {
};
#ifdef CONFIG_PM_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);
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)
{
}