PM / OPP: rename functions to dev_pm_opp*

Since Operating Performance Points (OPP) functions are specific to
device specific power management, be specific and rename opp_*
accessors in OPP library with dev_pm_opp_* equivalent.

Affected functions are:
 opp_get_voltage
 opp_get_freq
 opp_get_opp_count
 opp_find_freq_exact
 opp_find_freq_floor
 opp_find_freq_ceil
 opp_add
 opp_enable
 opp_disable
 opp_get_notifier
 opp_init_cpufreq_table
 opp_free_cpufreq_table

Reported-by: Randy Dunlap <rdunlap@infradead.org>
Signed-off-by: Nishanth Menon <nm@ti.com>
Acked-by: Viresh Kumar <viresh.kumar@linaro.org>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>

9 files changed, 101 insertions, 99 deletions

diff --git a/drivers/base/power/opp.c b/drivers/base/power/opp.c
index ef89897c6043..00c6a449cdeb 100644
--- a/drivers/base/power/opp.c
+++ b/drivers/base/power/opp.c
@@ -136,7 +136,7 @@ static struct device_opp *find_device_opp(struct device *dev)
 }
 
 /**
- * opp_get_voltage() - Gets the voltage corresponding to an available opp
+ * dev_pm_opp_get_voltage() - Gets the voltage corresponding to an available opp
  * @opp:        opp for which voltage has to be returned for
  *
  * Return voltage in micro volt corresponding to the opp, else
@@ -150,7 +150,7 @@ static struct device_opp *find_device_opp(struct device *dev)
  * prior to unlocking with rcu_read_unlock() to maintain the integrity of the
  * pointer.
  */
-unsigned long opp_get_voltage(struct opp *opp)
+unsigned long dev_pm_opp_get_voltage(struct opp *opp)
 {
         struct opp *tmp_opp;
         unsigned long v = 0;
@@ -163,10 +163,10 @@ unsigned long opp_get_voltage(struct opp *opp)
 
         return v;
 }
-EXPORT_SYMBOL_GPL(opp_get_voltage);
+EXPORT_SYMBOL_GPL(dev_pm_opp_get_voltage);
 
 /**
- * opp_get_freq() - Gets the frequency corresponding to an available opp
+ * dev_pm_opp_get_freq() - Gets the frequency corresponding to an available opp
  * @opp:        opp for which frequency has to be returned for
  *
  * Return frequency in hertz corresponding to the opp, else
@@ -180,7 +180,7 @@ EXPORT_SYMBOL_GPL(opp_get_voltage);
  * prior to unlocking with rcu_read_unlock() to maintain the integrity of the
  * pointer.
  */
-unsigned long opp_get_freq(struct opp *opp)
+unsigned long dev_pm_opp_get_freq(struct opp *opp)
 {
         struct opp *tmp_opp;
         unsigned long f = 0;
@@ -193,10 +193,10 @@ unsigned long opp_get_freq(struct opp *opp)
 
         return f;
 }
-EXPORT_SYMBOL_GPL(opp_get_freq);
+EXPORT_SYMBOL_GPL(dev_pm_opp_get_freq);
 
 /**
- * opp_get_opp_count() - Get number of opps available in the opp list
+ * dev_pm_opp_get_opp_count() - Get number of opps available in the opp list
  * @dev:        device for which we do this operation
  *
  * This function returns the number of available opps if there are any,
@@ -206,7 +206,7 @@ EXPORT_SYMBOL_GPL(opp_get_freq);
  * internally references two RCU protected structures: device_opp and opp which
  * are safe as long as we are under a common RCU locked section.
  */
-int opp_get_opp_count(struct device *dev)
+int dev_pm_opp_get_opp_count(struct device *dev)
 {
         struct device_opp *dev_opp;
         struct opp *temp_opp;
@@ -226,10 +226,10 @@ int opp_get_opp_count(struct device *dev)
 
         return count;
 }
-EXPORT_SYMBOL_GPL(opp_get_opp_count);
+EXPORT_SYMBOL_GPL(dev_pm_opp_get_opp_count);
 
 /**
- * opp_find_freq_exact() - search for an exact frequency
+ * dev_pm_opp_find_freq_exact() - search for an exact frequency
  * @dev:                device for which we do this operation
  * @freq:               frequency to search for
  * @available:          true/false - match for available opp
@@ -254,7 +254,7 @@ EXPORT_SYMBOL_GPL(opp_get_opp_count);
  * under the locked area. The pointer returned must be used prior to unlocking
  * with rcu_read_unlock() to maintain the integrity of the pointer.
  */
-struct opp *opp_find_freq_exact(struct device *dev, unsigned long freq,
+struct opp *dev_pm_opp_find_freq_exact(struct device *dev, unsigned long freq,
                                 bool available)
 {
         struct device_opp *dev_opp;
@@ -277,10 +277,10 @@ struct opp *opp_find_freq_exact(struct device *dev, unsigned long freq,
 
         return opp;
 }
-EXPORT_SYMBOL_GPL(opp_find_freq_exact);
+EXPORT_SYMBOL_GPL(dev_pm_opp_find_freq_exact);
 
 /**
- * opp_find_freq_ceil() - Search for an rounded ceil freq
+ * dev_pm_opp_find_freq_ceil() - Search for an rounded ceil freq
  * @dev:        device for which we do this operation
  * @freq:       Start frequency
  *
@@ -300,7 +300,7 @@ EXPORT_SYMBOL_GPL(opp_find_freq_exact);
  * under the locked area. The pointer returned must be used prior to unlocking
  * with rcu_read_unlock() to maintain the integrity of the pointer.
  */
-struct opp *opp_find_freq_ceil(struct device *dev, unsigned long *freq)
+struct opp *dev_pm_opp_find_freq_ceil(struct device *dev, unsigned long *freq)
 {
         struct device_opp *dev_opp;
         struct opp *temp_opp, *opp = ERR_PTR(-ERANGE);
@@ -324,10 +324,10 @@ struct opp *opp_find_freq_ceil(struct device *dev, unsigned long *freq)
 
         return opp;
 }
-EXPORT_SYMBOL_GPL(opp_find_freq_ceil);
+EXPORT_SYMBOL_GPL(dev_pm_opp_find_freq_ceil);
 
 /**
- * opp_find_freq_floor() - Search for a rounded floor freq
+ * dev_pm_opp_find_freq_floor() - Search for a rounded floor freq
  * @dev:        device for which we do this operation
  * @freq:       Start frequency
  *
@@ -347,7 +347,7 @@ EXPORT_SYMBOL_GPL(opp_find_freq_ceil);
  * under the locked area. The pointer returned must be used prior to unlocking
  * with rcu_read_unlock() to maintain the integrity of the pointer.
  */
-struct opp *opp_find_freq_floor(struct device *dev, unsigned long *freq)
+struct opp *dev_pm_opp_find_freq_floor(struct device *dev, unsigned long *freq)
 {
         struct device_opp *dev_opp;
         struct opp *temp_opp, *opp = ERR_PTR(-ERANGE);
@@ -375,17 +375,17 @@ struct opp *opp_find_freq_floor(struct device *dev, unsigned long *freq)
 
         return opp;
 }
-EXPORT_SYMBOL_GPL(opp_find_freq_floor);
+EXPORT_SYMBOL_GPL(dev_pm_opp_find_freq_floor);
 
 /**
- * opp_add()  - Add an OPP table from a table definitions
+ * dev_pm_opp_add()  - Add an OPP table from a table definitions
  * @dev:        device for which we do this operation
  * @freq:       Frequency in Hz for this OPP
  * @u_volt:     Voltage in uVolts for this OPP
  *
  * This function adds an opp definition to the opp list and returns status.
  * The opp is made available by default and it can be controlled using
- * opp_enable/disable functions.
+ * dev_pm_opp_enable/disable functions.
  *
  * Locking: The internal device_opp and opp structures are RCU protected.
  * Hence this function internally uses RCU updater strategy with mutex locks
@@ -393,7 +393,7 @@ EXPORT_SYMBOL_GPL(opp_find_freq_floor);
  * that this function is *NOT* called under RCU protection or in contexts where
  * mutex cannot be locked.
  */
-int opp_add(struct device *dev, unsigned long freq, unsigned long u_volt)
+int dev_pm_opp_add(struct device *dev, unsigned long freq, unsigned long u_volt)
 {
         struct device_opp *dev_opp = NULL;
         struct opp *opp, *new_opp;
@@ -460,7 +460,7 @@ int opp_add(struct device *dev, unsigned long freq, unsigned long u_volt)
         srcu_notifier_call_chain(&dev_opp->head, OPP_EVENT_ADD, new_opp);
         return 0;
 }
-EXPORT_SYMBOL_GPL(opp_add);
+EXPORT_SYMBOL_GPL(dev_pm_opp_add);
 
 /**
  * opp_set_availability() - helper to set the availability of an opp
@@ -552,13 +552,13 @@ unlock:
 }
 
 /**
- * opp_enable() - Enable a specific OPP
+ * dev_pm_opp_enable() - Enable a specific OPP
  * @dev:        device for which we do this operation
  * @freq:       OPP frequency to enable
  *
  * Enables a provided opp. If the operation is valid, this returns 0, else the
  * corresponding error value. It is meant to be used for users an OPP available
- * after being temporarily made unavailable with opp_disable.
+ * after being temporarily made unavailable with dev_pm_opp_disable.
  *
  * Locking: The internal device_opp and opp structures are RCU protected.
  * Hence this function indirectly uses RCU and mutex locks to keep the
@@ -566,21 +566,21 @@ unlock:
  * this function is *NOT* called under RCU protection or in contexts where
  * mutex locking or synchronize_rcu() blocking calls cannot be used.
  */
-int opp_enable(struct device *dev, unsigned long freq)
+int dev_pm_opp_enable(struct device *dev, unsigned long freq)
 {
         return opp_set_availability(dev, freq, true);
 }
-EXPORT_SYMBOL_GPL(opp_enable);
+EXPORT_SYMBOL_GPL(dev_pm_opp_enable);
 
 /**
- * opp_disable() - Disable a specific OPP
+ * dev_pm_opp_disable() - Disable a specific OPP
  * @dev:        device for which we do this operation
  * @freq:       OPP frequency to disable
  *
  * Disables a provided opp. If the operation is valid, this returns
  * 0, else the corresponding error value. It is meant to be a temporary
  * control by users to make this OPP not available until the circumstances are
- * right to make it available again (with a call to opp_enable).
+ * right to make it available again (with a call to dev_pm_opp_enable).
  *
  * Locking: The internal device_opp and opp structures are RCU protected.
  * Hence this function indirectly uses RCU and mutex locks to keep the
@@ -588,15 +588,15 @@ EXPORT_SYMBOL_GPL(opp_enable);
  * this function is *NOT* called under RCU protection or in contexts where
  * mutex locking or synchronize_rcu() blocking calls cannot be used.
  */
-int opp_disable(struct device *dev, unsigned long freq)
+int dev_pm_opp_disable(struct device *dev, unsigned long freq)
 {
         return opp_set_availability(dev, freq, false);
 }
-EXPORT_SYMBOL_GPL(opp_disable);
+EXPORT_SYMBOL_GPL(dev_pm_opp_disable);
 
 #ifdef CONFIG_CPU_FREQ
 /**
- * opp_init_cpufreq_table() - create a cpufreq table for a device
+ * dev_pm_opp_init_cpufreq_table() - create a cpufreq table for a device
  * @dev:        device for which we do this operation
  * @table:      Cpufreq table returned back to caller
  *
@@ -619,7 +619,7 @@ EXPORT_SYMBOL_GPL(opp_disable);
  * Callers should ensure that this function is *NOT* called under RCU protection
  * or in contexts where mutex locking cannot be used.
  */
-int opp_init_cpufreq_table(struct device *dev,
+int dev_pm_opp_init_cpufreq_table(struct device *dev,
                             struct cpufreq_frequency_table **table)
 {
         struct device_opp *dev_opp;
@@ -639,7 +639,7 @@ int opp_init_cpufreq_table(struct device *dev,
         }
 
         freq_table = kzalloc(sizeof(struct cpufreq_frequency_table) *
-                             (opp_get_opp_count(dev) + 1), GFP_KERNEL);
+                             (dev_pm_opp_get_opp_count(dev) + 1), GFP_KERNEL);
         if (!freq_table) {
                 mutex_unlock(&dev_opp_list_lock);
                 dev_warn(dev, "%s: Unable to allocate frequency table\n",
@@ -663,16 +663,16 @@ int opp_init_cpufreq_table(struct device *dev,
 
         return 0;
 }
-EXPORT_SYMBOL_GPL(opp_init_cpufreq_table);
+EXPORT_SYMBOL_GPL(dev_pm_opp_init_cpufreq_table);
 
 /**
- * opp_free_cpufreq_table() - free the cpufreq table
+ * dev_pm_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
+ * Free up the table allocated by dev_pm_opp_init_cpufreq_table
  */
-void opp_free_cpufreq_table(struct device *dev,
+void dev_pm_opp_free_cpufreq_table(struct device *dev,
                                 struct cpufreq_frequency_table **table)
 {
         if (!table)
@@ -681,14 +681,14 @@ void opp_free_cpufreq_table(struct device *dev,
         kfree(*table);
         *table = NULL;
 }
-EXPORT_SYMBOL_GPL(opp_free_cpufreq_table);
+EXPORT_SYMBOL_GPL(dev_pm_opp_free_cpufreq_table);
 #endif          /* CONFIG_CPU_FREQ */
 
 /**
- * opp_get_notifier() - find notifier_head of the device with opp
+ * dev_pm_opp_get_notifier() - find notifier_head of the device with opp
  * @dev:        device pointer used to lookup device OPPs.
  */
-struct srcu_notifier_head *opp_get_notifier(struct device *dev)
+struct srcu_notifier_head *dev_pm_opp_get_notifier(struct device *dev)
 {
         struct device_opp *dev_opp = find_device_opp(dev);
 
@@ -732,7 +732,7 @@ int of_init_opp_table(struct device *dev)
                 unsigned long freq = be32_to_cpup(val++) * 1000;
                 unsigned long volt = be32_to_cpup(val++);
 
-                if (opp_add(dev, freq, volt)) {
+                if (dev_pm_opp_add(dev, freq, volt)) {
                         dev_warn(dev, "%s: Failed to add OPP %ld\n",
                                  __func__, freq);
                         continue;
diff --git a/drivers/cpufreq/arm_big_little.c b/drivers/cpufreq/arm_big_little.c
index 3549f0784af1..9e82a9d5df77 100644
--- a/drivers/cpufreq/arm_big_little.c
+++ b/drivers/cpufreq/arm_big_little.c
@@ -98,7 +98,7 @@ static void put_cluster_clk_and_freq_table(struct device *cpu_dev)
 
         if (!atomic_dec_return(&cluster_usage[cluster])) {
                 clk_put(clk[cluster]);
-                opp_free_cpufreq_table(cpu_dev, &freq_table[cluster]);
+                dev_pm_opp_free_cpufreq_table(cpu_dev, &freq_table[cluster]);
                 dev_dbg(cpu_dev, "%s: cluster: %d\n", __func__, cluster);
         }
 }
@@ -119,7 +119,7 @@ static int get_cluster_clk_and_freq_table(struct device *cpu_dev)
                 goto atomic_dec;
         }
 
-        ret = opp_init_cpufreq_table(cpu_dev, &freq_table[cluster]);
+        ret = dev_pm_opp_init_cpufreq_table(cpu_dev, &freq_table[cluster]);
         if (ret) {
                 dev_err(cpu_dev, "%s: failed to init cpufreq table, cpu: %d, err: %d\n",
                                 __func__, cpu_dev->id, ret);
@@ -138,7 +138,7 @@ static int get_cluster_clk_and_freq_table(struct device *cpu_dev)
         dev_err(cpu_dev, "%s: Failed to get clk for cpu: %d, cluster: %d\n",
                         __func__, cpu_dev->id, cluster);
         ret = PTR_ERR(clk[cluster]);
-        opp_free_cpufreq_table(cpu_dev, &freq_table[cluster]);
+        dev_pm_opp_free_cpufreq_table(cpu_dev, &freq_table[cluster]);
 
 atomic_dec:
         atomic_dec(&cluster_usage[cluster]);
diff --git a/drivers/cpufreq/cpufreq-cpu0.c b/drivers/cpufreq/cpufreq-cpu0.c
index c522a95c0e16..af951a9cea78 100644
--- a/drivers/cpufreq/cpufreq-cpu0.c
+++ b/drivers/cpufreq/cpufreq-cpu0.c
@@ -72,7 +72,7 @@ static int cpu0_set_target(struct cpufreq_policy *policy,
 
         if (!IS_ERR(cpu_reg)) {
                 rcu_read_lock();
-                opp = opp_find_freq_ceil(cpu_dev, &freq_Hz);
+                opp = dev_pm_opp_find_freq_ceil(cpu_dev, &freq_Hz);
                 if (IS_ERR(opp)) {
                         rcu_read_unlock();
                         pr_err("failed to find OPP for %ld\n", freq_Hz);
@@ -80,7 +80,7 @@ static int cpu0_set_target(struct cpufreq_policy *policy,
                         ret = PTR_ERR(opp);
                         goto post_notify;
                 }
-                volt = opp_get_voltage(opp);
+                volt = dev_pm_opp_get_voltage(opp);
                 rcu_read_unlock();
                 tol = volt * voltage_tolerance / 100;
                 volt_old = regulator_get_voltage(cpu_reg);
@@ -218,7 +218,7 @@ static int cpu0_cpufreq_probe(struct platform_device *pdev)
                 goto out_put_node;
         }
 
-        ret = opp_init_cpufreq_table(cpu_dev, &freq_table);
+        ret = dev_pm_opp_init_cpufreq_table(cpu_dev, &freq_table);
         if (ret) {
                 pr_err("failed to init cpufreq table: %d\n", ret);
                 goto out_put_node;
@@ -242,12 +242,12 @@ static int cpu0_cpufreq_probe(struct platform_device *pdev)
                 for (i = 0; freq_table[i].frequency != CPUFREQ_TABLE_END; i++)
                         ;
                 rcu_read_lock();
-                opp = opp_find_freq_exact(cpu_dev,
+                opp = dev_pm_opp_find_freq_exact(cpu_dev,
                                 freq_table[0].frequency * 1000, true);
-                min_uV = opp_get_voltage(opp);
-                opp = opp_find_freq_exact(cpu_dev,
+                min_uV = dev_pm_opp_get_voltage(opp);
+                opp = dev_pm_opp_find_freq_exact(cpu_dev,
                                 freq_table[i-1].frequency * 1000, true);
-                max_uV = opp_get_voltage(opp);
+                max_uV = dev_pm_opp_get_voltage(opp);
                 rcu_read_unlock();
                 ret = regulator_set_voltage_time(cpu_reg, min_uV, max_uV);
                 if (ret > 0)
@@ -264,7 +264,7 @@ static int cpu0_cpufreq_probe(struct platform_device *pdev)
         return 0;
 
 out_free_table:
-        opp_free_cpufreq_table(cpu_dev, &freq_table);
+        dev_pm_opp_free_cpufreq_table(cpu_dev, &freq_table);
 out_put_node:
         of_node_put(np);
         return ret;
@@ -273,7 +273,7 @@ out_put_node:
 static int cpu0_cpufreq_remove(struct platform_device *pdev)
 {
         cpufreq_unregister_driver(&cpu0_cpufreq_driver);
-        opp_free_cpufreq_table(cpu_dev, &freq_table);
+        dev_pm_opp_free_cpufreq_table(cpu_dev, &freq_table);
 
         return 0;
 }
diff --git a/drivers/cpufreq/exynos5440-cpufreq.c b/drivers/cpufreq/exynos5440-cpufreq.c
index be5380ecdcd4..444eca74d3c2 100644
--- a/drivers/cpufreq/exynos5440-cpufreq.c
+++ b/drivers/cpufreq/exynos5440-cpufreq.c
@@ -123,7 +123,7 @@ static int init_div_table(void)
         rcu_read_lock();
         for (i = 0; freq_tbl[i].frequency != CPUFREQ_TABLE_END; i++) {
 
-                opp = opp_find_freq_exact(dvfs_info->dev,
+                opp = dev_pm_opp_find_freq_exact(dvfs_info->dev,
                                         freq_tbl[i].frequency * 1000, true);
                 if (IS_ERR(opp)) {
                         rcu_read_unlock();
@@ -142,7 +142,7 @@ static int init_div_table(void)
                                         << P0_7_CSCLKDEV_SHIFT;
 
                 /* Calculate EMA */
-                volt_id = opp_get_voltage(opp);
+                volt_id = dev_pm_opp_get_voltage(opp);
                 volt_id = (MAX_VOLTAGE - volt_id) / VOLTAGE_STEP;
                 if (volt_id < PMIC_HIGH_VOLT) {
                         ema_div = (CPUEMA_HIGH << P0_7_CPUEMA_SHIFT) |
@@ -399,13 +399,14 @@ static int exynos_cpufreq_probe(struct platform_device *pdev)
                 goto err_put_node;
         }
 
-        ret = opp_init_cpufreq_table(dvfs_info->dev, &dvfs_info->freq_table);
+        ret = dev_pm_opp_init_cpufreq_table(dvfs_info->dev,
+                                            &dvfs_info->freq_table);
         if (ret) {
                 dev_err(dvfs_info->dev,
                         "failed to init cpufreq table: %d\n", ret);
                 goto err_put_node;
         }
-        dvfs_info->freq_count = opp_get_opp_count(dvfs_info->dev);
+        dvfs_info->freq_count = dev_pm_opp_get_opp_count(dvfs_info->dev);
         exynos_sort_descend_freq_table();
 
         if (of_property_read_u32(np, "clock-latency", &dvfs_info->latency))
@@ -454,7 +455,7 @@ static int exynos_cpufreq_probe(struct platform_device *pdev)
         return 0;
 
 err_free_table:
-        opp_free_cpufreq_table(dvfs_info->dev, &dvfs_info->freq_table);
+        dev_pm_opp_free_cpufreq_table(dvfs_info->dev, &dvfs_info->freq_table);
 err_put_node:
         of_node_put(np);
         dev_err(&pdev->dev, "%s: failed initialization\n", __func__);
@@ -464,7 +465,7 @@ err_put_node:
 static int exynos_cpufreq_remove(struct platform_device *pdev)
 {
         cpufreq_unregister_driver(&exynos_driver);
-        opp_free_cpufreq_table(dvfs_info->dev, &dvfs_info->freq_table);
+        dev_pm_opp_free_cpufreq_table(dvfs_info->dev, &dvfs_info->freq_table);
         return 0;
 }
 
diff --git a/drivers/cpufreq/imx6q-cpufreq.c b/drivers/cpufreq/imx6q-cpufreq.c
index c3fd2a101ca0..b360549e7715 100644
--- a/drivers/cpufreq/imx6q-cpufreq.c
+++ b/drivers/cpufreq/imx6q-cpufreq.c
@@ -70,14 +70,14 @@ static int imx6q_set_target(struct cpufreq_policy *policy,
                 return 0;
 
         rcu_read_lock();
-        opp = opp_find_freq_ceil(cpu_dev, &freq_hz);
+        opp = dev_pm_opp_find_freq_ceil(cpu_dev, &freq_hz);
         if (IS_ERR(opp)) {
                 rcu_read_unlock();
                 dev_err(cpu_dev, "failed to find OPP for %ld\n", freq_hz);
                 return PTR_ERR(opp);
         }
 
-        volt = opp_get_voltage(opp);
+        volt = dev_pm_opp_get_voltage(opp);
         rcu_read_unlock();
         volt_old = regulator_get_voltage(arm_reg);
 
@@ -237,14 +237,14 @@ static int imx6q_cpufreq_probe(struct platform_device *pdev)
         }
 
         /* We expect an OPP table supplied by platform */
-        num = opp_get_opp_count(cpu_dev);
+        num = dev_pm_opp_get_opp_count(cpu_dev);
         if (num < 0) {
                 ret = num;
                 dev_err(cpu_dev, "no OPP table is found: %d\n", ret);
                 goto put_node;
         }
 
-        ret = opp_init_cpufreq_table(cpu_dev, &freq_table);
+        ret = dev_pm_opp_init_cpufreq_table(cpu_dev, &freq_table);
         if (ret) {
                 dev_err(cpu_dev, "failed to init cpufreq table: %d\n", ret);
                 goto put_node;
@@ -259,12 +259,12 @@ static int imx6q_cpufreq_probe(struct platform_device *pdev)
          * same order.
          */
         rcu_read_lock();
-        opp = opp_find_freq_exact(cpu_dev,
+        opp = dev_pm_opp_find_freq_exact(cpu_dev,
                                   freq_table[0].frequency * 1000, true);
-        min_volt = opp_get_voltage(opp);
-        opp = opp_find_freq_exact(cpu_dev,
+        min_volt = dev_pm_opp_get_voltage(opp);
+        opp = dev_pm_opp_find_freq_exact(cpu_dev,
                                   freq_table[--num].frequency * 1000, true);
-        max_volt = opp_get_voltage(opp);
+        max_volt = dev_pm_opp_get_voltage(opp);
         rcu_read_unlock();
         ret = regulator_set_voltage_time(arm_reg, min_volt, max_volt);
         if (ret > 0)
@@ -292,7 +292,7 @@ static int imx6q_cpufreq_probe(struct platform_device *pdev)
         return 0;
 
 free_freq_table:
-        opp_free_cpufreq_table(cpu_dev, &freq_table);
+        dev_pm_opp_free_cpufreq_table(cpu_dev, &freq_table);
 put_node:
         of_node_put(np);
         return ret;
@@ -301,7 +301,7 @@ put_node:
 static int imx6q_cpufreq_remove(struct platform_device *pdev)
 {
         cpufreq_unregister_driver(&imx6q_cpufreq_driver);
-        opp_free_cpufreq_table(cpu_dev, &freq_table);
+        dev_pm_opp_free_cpufreq_table(cpu_dev, &freq_table);
 
         return 0;
 }
diff --git a/drivers/cpufreq/omap-cpufreq.c b/drivers/cpufreq/omap-cpufreq.c
index f31fcfcad514..c5e31d296607 100644
--- a/drivers/cpufreq/omap-cpufreq.c
+++ b/drivers/cpufreq/omap-cpufreq.c
@@ -105,14 +105,14 @@ static int omap_target(struct cpufreq_policy *policy,
 
         if (mpu_reg) {
                 rcu_read_lock();
-                opp = opp_find_freq_ceil(mpu_dev, &freq);
+                opp = dev_pm_opp_find_freq_ceil(mpu_dev, &freq);
                 if (IS_ERR(opp)) {
                         rcu_read_unlock();
                         dev_err(mpu_dev, "%s: unable to find MPU OPP for %d\n",
                                 __func__, freqs.new);
                         return -EINVAL;
                 }
-                volt = opp_get_voltage(opp);
+                volt = dev_pm_opp_get_voltage(opp);
                 rcu_read_unlock();
                 tol = volt * OPP_TOLERANCE / 100;
                 volt_old = regulator_get_voltage(mpu_reg);
@@ -162,7 +162,7 @@ done:
 static inline void freq_table_free(void)
 {
         if (atomic_dec_and_test(&freq_table_users))
-                opp_free_cpufreq_table(mpu_dev, &freq_table);
+                dev_pm_opp_free_cpufreq_table(mpu_dev, &freq_table);
 }
 
 static int omap_cpu_init(struct cpufreq_policy *policy)
@@ -181,7 +181,7 @@ static int omap_cpu_init(struct cpufreq_policy *policy)
         policy->cur = omap_getspeed(policy->cpu);
 
         if (!freq_table)
-                result = opp_init_cpufreq_table(mpu_dev, &freq_table);
+                result = dev_pm_opp_init_cpufreq_table(mpu_dev, &freq_table);
 
         if (result) {
                 dev_err(mpu_dev, "%s: cpu%d: failed creating freq table[%d]\n",
diff --git a/drivers/devfreq/devfreq.c b/drivers/devfreq/devfreq.c
index c99c00d35d34..f798edcb910d 100644
--- a/drivers/devfreq/devfreq.c
+++ b/drivers/devfreq/devfreq.c
@@ -908,7 +908,7 @@ static ssize_t available_frequencies_show(struct device *d,
 
         rcu_read_lock();
         do {
-                opp = opp_find_freq_ceil(dev, &freq);
+                opp = dev_pm_opp_find_freq_ceil(dev, &freq);
                 if (IS_ERR(opp))
                         break;
 
@@ -1036,18 +1036,18 @@ struct opp *devfreq_recommended_opp(struct device *dev, unsigned long *freq,
 
         if (flags & DEVFREQ_FLAG_LEAST_UPPER_BOUND) {
                 /* The freq is an upper bound. opp should be lower */
-                opp = opp_find_freq_floor(dev, freq);
+                opp = dev_pm_opp_find_freq_floor(dev, freq);
 
                 /* If not available, use the closest opp */
                 if (opp == ERR_PTR(-ERANGE))
-                        opp = opp_find_freq_ceil(dev, freq);
+                        opp = dev_pm_opp_find_freq_ceil(dev, freq);
         } else {
                 /* The freq is an lower bound. opp should be higher */
-                opp = opp_find_freq_ceil(dev, freq);
+                opp = dev_pm_opp_find_freq_ceil(dev, freq);
 
                 /* If not available, use the closest opp */
                 if (opp == ERR_PTR(-ERANGE))
-                        opp = opp_find_freq_floor(dev, freq);
+                        opp = dev_pm_opp_find_freq_floor(dev, freq);
         }
 
         return opp;
@@ -1066,7 +1066,7 @@ int devfreq_register_opp_notifier(struct device *dev, struct devfreq *devfreq)
         int ret = 0;
 
         rcu_read_lock();
-        nh = opp_get_notifier(dev);
+        nh = dev_pm_opp_get_notifier(dev);
         if (IS_ERR(nh))
                 ret = PTR_ERR(nh);
         rcu_read_unlock();
@@ -1092,7 +1092,7 @@ int devfreq_unregister_opp_notifier(struct device *dev, struct devfreq *devfreq)
         int ret = 0;
 
         rcu_read_lock();
-        nh = opp_get_notifier(dev);
+        nh = dev_pm_opp_get_notifier(dev);
         if (IS_ERR(nh))
                 ret = PTR_ERR(nh);
         rcu_read_unlock();
diff --git a/drivers/devfreq/exynos/exynos4_bus.c b/drivers/devfreq/exynos/exynos4_bus.c
index c5f86d8caca3..33c0e05a5ff1 100644
--- a/drivers/devfreq/exynos/exynos4_bus.c
+++ b/drivers/devfreq/exynos/exynos4_bus.c
@@ -650,8 +650,8 @@ static int exynos4_bus_target(struct device *dev, unsigned long *_freq,
                 rcu_read_unlock();
                 return PTR_ERR(opp);
         }
-        new_oppinfo.rate = opp_get_freq(opp);
-        new_oppinfo.volt = opp_get_voltage(opp);
+        new_oppinfo.rate = dev_pm_opp_get_freq(opp);
+        new_oppinfo.volt = dev_pm_opp_get_voltage(opp);
         rcu_read_unlock();
         freq = new_oppinfo.rate;
 
@@ -873,7 +873,7 @@ static int exynos4210_init_tables(struct busfreq_data *data)
                 exynos4210_busclk_table[i].volt = exynos4210_asv_volt[mgrp][i];
 
         for (i = LV_0; i < EX4210_LV_NUM; i++) {
-                err = opp_add(data->dev, exynos4210_busclk_table[i].clk,
+                err = dev_pm_opp_add(data->dev, exynos4210_busclk_table[i].clk,
                               exynos4210_busclk_table[i].volt);
                 if (err) {
                         dev_err(data->dev, "Cannot add opp entries.\n");
@@ -940,7 +940,7 @@ static int exynos4x12_init_tables(struct busfreq_data *data)
         }
 
         for (i = 0; i < EX4x12_LV_NUM; i++) {
-                ret = opp_add(data->dev, exynos4x12_mifclk_table[i].clk,
+                ret = dev_pm_opp_add(data->dev, exynos4x12_mifclk_table[i].clk,
                               exynos4x12_mifclk_table[i].volt);
                 if (ret) {
                         dev_err(data->dev, "Fail to add opp entries.\n");
@@ -969,7 +969,7 @@ static int exynos4_busfreq_pm_notifier_event(struct notifier_block *this,
                 data->disabled = true;
 
                 rcu_read_lock();
-                opp = opp_find_freq_floor(data->dev, &maxfreq);
+                opp = dev_pm_opp_find_freq_floor(data->dev, &maxfreq);
                 if (IS_ERR(opp)) {
                         rcu_read_unlock();
                         dev_err(data->dev, "%s: unable to find a min freq\n",
@@ -977,8 +977,8 @@ static int exynos4_busfreq_pm_notifier_event(struct notifier_block *this,
                         mutex_unlock(&data->lock);
                         return PTR_ERR(opp);
                 }
-                new_oppinfo.rate = opp_get_freq(opp);
-                new_oppinfo.volt = opp_get_voltage(opp);
+                new_oppinfo.rate = dev_pm_opp_get_freq(opp);
+                new_oppinfo.volt = dev_pm_opp_get_voltage(opp);
                 rcu_read_unlock();
 
                 err = exynos4_bus_setvolt(data, &new_oppinfo,
@@ -1065,15 +1065,16 @@ static int exynos4_busfreq_probe(struct platform_device *pdev)
         }
 
         rcu_read_lock();
-        opp = opp_find_freq_floor(dev, &exynos4_devfreq_profile.initial_freq);
+        opp = dev_pm_opp_find_freq_floor(dev,
+                                         &exynos4_devfreq_profile.initial_freq);
         if (IS_ERR(opp)) {
                 rcu_read_unlock();
                 dev_err(dev, "Invalid initial frequency %lu kHz.\n",
                         exynos4_devfreq_profile.initial_freq);
                 return PTR_ERR(opp);
         }
-        data->curr_oppinfo.rate = opp_get_freq(opp);
-        data->curr_oppinfo.volt = opp_get_voltage(opp);
+        data->curr_oppinfo.rate = dev_pm_opp_get_freq(opp);
+        data->curr_oppinfo.volt = dev_pm_opp_get_voltage(opp);
         rcu_read_unlock();
 
         platform_set_drvdata(pdev, data);
diff --git a/drivers/devfreq/exynos/exynos5_bus.c b/drivers/devfreq/exynos/exynos5_bus.c
index 574b16b59be5..b0e45925505b 100644
--- a/drivers/devfreq/exynos/exynos5_bus.c
+++ b/drivers/devfreq/exynos/exynos5_bus.c
@@ -144,8 +144,8 @@ static int exynos5_busfreq_int_target(struct device *dev, unsigned long *_freq,
                 return PTR_ERR(opp);
         }
 
-        freq = opp_get_freq(opp);
-        volt = opp_get_voltage(opp);
+        freq = dev_pm_opp_get_freq(opp);
+        volt = dev_pm_opp_get_voltage(opp);
         rcu_read_unlock();
 
         old_freq = data->curr_freq;
@@ -246,7 +246,7 @@ static int exynos5250_init_int_tables(struct busfreq_data_int *data)
         int i, err = 0;
 
         for (i = LV_0; i < _LV_END; i++) {
-                err = opp_add(data->dev, exynos5_int_opp_table[i].clk,
+                err = dev_pm_opp_add(data->dev, exynos5_int_opp_table[i].clk,
                                 exynos5_int_opp_table[i].volt);
                 if (err) {
                         dev_err(data->dev, "Cannot add opp entries.\n");
@@ -276,14 +276,14 @@ static int exynos5_busfreq_int_pm_notifier_event(struct notifier_block *this,
                 data->disabled = true;
 
                 rcu_read_lock();
-                opp = opp_find_freq_floor(data->dev, &maxfreq);
+                opp = dev_pm_opp_find_freq_floor(data->dev, &maxfreq);
                 if (IS_ERR(opp)) {
                         rcu_read_unlock();
                         err = PTR_ERR(opp);
                         goto unlock;
                 }
-                freq = opp_get_freq(opp);
-                volt = opp_get_voltage(opp);
+                freq = dev_pm_opp_get_freq(opp);
+                volt = dev_pm_opp_get_voltage(opp);
                 rcu_read_unlock();
 
                 err = exynos5_int_setvolt(data, volt);
@@ -368,7 +368,7 @@ static int exynos5_busfreq_int_probe(struct platform_device *pdev)
         }
 
         rcu_read_lock();
-        opp = opp_find_freq_floor(dev,
+        opp = dev_pm_opp_find_freq_floor(dev,
                         &exynos5_devfreq_int_profile.initial_freq);
         if (IS_ERR(opp)) {
                 rcu_read_unlock();
@@ -377,8 +377,8 @@ static int exynos5_busfreq_int_probe(struct platform_device *pdev)
                 err = PTR_ERR(opp);
                 goto err_opp_add;
         }
-        initial_freq = opp_get_freq(opp);
-        initial_volt = opp_get_voltage(opp);
+        initial_freq = dev_pm_opp_get_freq(opp);
+        initial_volt = dev_pm_opp_get_voltage(opp);
         rcu_read_unlock();
         data->curr_freq = initial_freq;