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>

1 files changed, 94 insertions, 94 deletions

diff --git a/drivers/base/power/clock_ops.c b/drivers/base/power/clock_ops.c
index 2fb9c121c64b..a846b2f95cfb 100644
--- a/drivers/base/power/clock_ops.c
+++ b/drivers/base/power/clock_ops.c
@@ -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);
 }