cpufreq: powerpc_cbe: Switch to QoS requests for freq limits

The cpufreq core now takes the min/max frequency constraints via QoS
requests and the CPUFREQ_ADJUST notifier shall get removed later on.

Switch over to using the QoS request for maximum frequency constraint
for ppc_cbe_cpufreq driver.

Signed-off-by: Viresh Kumar <viresh.kumar@linaro.org>
[ rjw: Subject ]
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>

diff --git a/drivers/cpufreq/ppc_cbe_cpufreq.c b/drivers/cpufreq/ppc_cbe_cpufreq.c
index b83f36f..c58abb4 100644 (file)
--- a/drivers/cpufreq/ppc_cbe_cpufreq.c
+++ b/drivers/cpufreq/ppc_cbe_cpufreq.c
@@ -110,6 +110,13 @@ static int cbe_cpufreq_cpu_init(struct cpufreq_policy *policy)
 #endif
 
        policy->freq_table = cbe_freqs;
+       cbe_cpufreq_pmi_policy_init(policy);
+       return 0;
+}
+
+static int cbe_cpufreq_cpu_exit(struct cpufreq_policy *policy)
+{
+       cbe_cpufreq_pmi_policy_exit(policy);
        return 0;
 }
 
@@ -129,6 +136,7 @@ static struct cpufreq_driver cbe_cpufreq_driver = {
        .verify         = cpufreq_generic_frequency_table_verify,
        .target_index   = cbe_cpufreq_target,
        .init           = cbe_cpufreq_cpu_init,
+       .exit           = cbe_cpufreq_cpu_exit,
        .name           = "cbe-cpufreq",
        .flags          = CPUFREQ_CONST_LOOPS,
 };
@@ -139,15 +147,24 @@ static struct cpufreq_driver cbe_cpufreq_driver = {
 
 static int __init cbe_cpufreq_init(void)
 {
+       int ret;
+
        if (!machine_is(cell))
                return -ENODEV;
 
-       return cpufreq_register_driver(&cbe_cpufreq_driver);
+       cbe_cpufreq_pmi_init();
+
+       ret = cpufreq_register_driver(&cbe_cpufreq_driver);
+       if (ret)
+               cbe_cpufreq_pmi_exit();
+
+       return ret;
 }
 
 static void __exit cbe_cpufreq_exit(void)
 {
        cpufreq_unregister_driver(&cbe_cpufreq_driver);
+       cbe_cpufreq_pmi_exit();
 }
 
 module_init(cbe_cpufreq_init);

diff --git a/drivers/cpufreq/ppc_cbe_cpufreq.h b/drivers/cpufreq/ppc_cbe_cpufreq.h
index 9d97351..00cd863 100644 (file)
--- a/drivers/cpufreq/ppc_cbe_cpufreq.h
+++ b/drivers/cpufreq/ppc_cbe_cpufreq.h
@@ -20,6 +20,14 @@ int cbe_cpufreq_set_pmode_pmi(int cpu, unsigned int pmode);
 
 #if IS_ENABLED(CONFIG_CPU_FREQ_CBE_PMI)
 extern bool cbe_cpufreq_has_pmi;
+void cbe_cpufreq_pmi_policy_init(struct cpufreq_policy *policy);
+void cbe_cpufreq_pmi_policy_exit(struct cpufreq_policy *policy);
+void cbe_cpufreq_pmi_init(void);
+void cbe_cpufreq_pmi_exit(void);
 #else
 #define cbe_cpufreq_has_pmi (0)
+static inline void cbe_cpufreq_pmi_policy_init(struct cpufreq_policy *policy) {}
+static inline void cbe_cpufreq_pmi_policy_exit(struct cpufreq_policy *policy) {}
+static inline void cbe_cpufreq_pmi_init(void) {}
+static inline void cbe_cpufreq_pmi_exit(void) {}
 #endif

diff --git a/drivers/cpufreq/ppc_cbe_cpufreq_pmi.c b/drivers/cpufreq/ppc_cbe_cpufreq_pmi.c
index 97c8ee4..bc9dd30 100644 (file)
--- a/drivers/cpufreq/ppc_cbe_cpufreq_pmi.c
+++ b/drivers/cpufreq/ppc_cbe_cpufreq_pmi.c
@@ -12,6 +12,7 @@
 #include <linux/timer.h>
 #include <linux/init.h>
 #include <linux/of_platform.h>
+#include <linux/pm_qos.h>
 
 #include <asm/processor.h>
 #include <asm/prom.h>
@@ -24,8 +25,6 @@
 
 #include "ppc_cbe_cpufreq.h"
 
-static u8 pmi_slow_mode_limit[MAX_CBE];
-
 bool cbe_cpufreq_has_pmi = false;
 EXPORT_SYMBOL_GPL(cbe_cpufreq_has_pmi);
 
@@ -65,64 +64,89 @@ EXPORT_SYMBOL_GPL(cbe_cpufreq_set_pmode_pmi);
 
 static void cbe_cpufreq_handle_pmi(pmi_message_t pmi_msg)
 {
+       struct cpufreq_policy *policy;
+       struct dev_pm_qos_request *req;
        u8 node, slow_mode;
+       int cpu, ret;
 
        BUG_ON(pmi_msg.type != PMI_TYPE_FREQ_CHANGE);
 
        node = pmi_msg.data1;
        slow_mode = pmi_msg.data2;
 
-       pmi_slow_mode_limit[node] = slow_mode;
+       cpu = cbe_node_to_cpu(node);
 
        pr_debug("cbe_handle_pmi: node: %d max_freq: %d\n", node, slow_mode);
-}
-
-static int pmi_notifier(struct notifier_block *nb,
-                                      unsigned long event, void *data)
-{
-       struct cpufreq_policy *policy = data;
-       struct cpufreq_frequency_table *cbe_freqs = policy->freq_table;
-       u8 node;
-
-       /* Should this really be called for CPUFREQ_ADJUST and CPUFREQ_NOTIFY
-        * policy events?)
-        */
-       node = cbe_cpu_to_node(policy->cpu);
-
-       pr_debug("got notified, event=%lu, node=%u\n", event, node);
 
-       if (pmi_slow_mode_limit[node] != 0) {
-               pr_debug("limiting node %d to slow mode %d\n",
-                        node, pmi_slow_mode_limit[node]);
+       policy = cpufreq_cpu_get(cpu);
+       if (!policy) {
+               pr_warn("cpufreq policy not found cpu%d\n", cpu);
+               return;
+       }
 
-               cpufreq_verify_within_limits(policy, 0,
+       req = policy->driver_data;
 
-                       cbe_freqs[pmi_slow_mode_limit[node]].frequency);
-       }
+       ret = dev_pm_qos_update_request(req,
+                       policy->freq_table[slow_mode].frequency);
+       if (ret < 0)
+               pr_warn("Failed to update freq constraint: %d\n", ret);
+       else
+               pr_debug("limiting node %d to slow mode %d\n", node, slow_mode);
 
-       return 0;
+       cpufreq_cpu_put(policy);
 }
 
-static struct notifier_block pmi_notifier_block = {
-       .notifier_call = pmi_notifier,
-};
-
 static struct pmi_handler cbe_pmi_handler = {
        .type                   = PMI_TYPE_FREQ_CHANGE,
        .handle_pmi_message     = cbe_cpufreq_handle_pmi,
 };
 
+void cbe_cpufreq_pmi_policy_init(struct cpufreq_policy *policy)
+{
+       struct dev_pm_qos_request *req;
+       int ret;
+
+       if (!cbe_cpufreq_has_pmi)
+               return;
+
+       req = kzalloc(sizeof(*req), GFP_KERNEL);
+       if (!req)
+               return;
+
+       ret = dev_pm_qos_add_request(get_cpu_device(policy->cpu), req,
+                                    DEV_PM_QOS_MAX_FREQUENCY,
+                                    policy->freq_table[0].frequency);
+       if (ret < 0) {
+               pr_err("Failed to add freq constraint (%d)\n", ret);
+               kfree(req);
+               return;
+       }
 
+       policy->driver_data = req;
+}
+EXPORT_SYMBOL_GPL(cbe_cpufreq_pmi_policy_init);
 
-static int __init cbe_cpufreq_pmi_init(void)
+void cbe_cpufreq_pmi_policy_exit(struct cpufreq_policy *policy)
 {
-       cbe_cpufreq_has_pmi = pmi_register_handler(&cbe_pmi_handler) == 0;
+       struct dev_pm_qos_request *req = policy->driver_data;
 
-       if (!cbe_cpufreq_has_pmi)
-               return -ENODEV;
+       if (cbe_cpufreq_has_pmi) {
+               dev_pm_qos_remove_request(req);
+               kfree(req);
+       }
+}
+EXPORT_SYMBOL_GPL(cbe_cpufreq_pmi_policy_exit);
 
-       cpufreq_register_notifier(&pmi_notifier_block, CPUFREQ_POLICY_NOTIFIER);
+void cbe_cpufreq_pmi_init(void)
+{
+       if (!pmi_register_handler(&cbe_pmi_handler))
+               cbe_cpufreq_has_pmi = true;
+}
+EXPORT_SYMBOL_GPL(cbe_cpufreq_pmi_init);
 
-       return 0;
+void cbe_cpufreq_pmi_exit(void)
+{
+       pmi_unregister_handler(&cbe_pmi_handler);
+       cbe_cpufreq_has_pmi = false;
 }
-device_initcall(cbe_cpufreq_pmi_init);
+EXPORT_SYMBOL_GPL(cbe_cpufreq_pmi_exit);