Commit afe96907 authored by Viresh Kumar's avatar Viresh Kumar Committed by Rafael J. Wysocki
Browse files

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: default avatarViresh Kumar <viresh.kumar@linaro.org>
[ rjw: Subject ]
Signed-off-by: default avatarRafael J. Wysocki <rafael.j.wysocki@intel.com>
parent dce2e3a8

drivers/cpufreq/ppc_cbe_cpufreq.c

+18 −1
Original line number Diff line number Diff line
@@ -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);

drivers/cpufreq/ppc_cbe_cpufreq.h

+8 −0
Original line number Diff line number Diff line
@@ -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

drivers/cpufreq/ppc_cbe_cpufreq_pmi.c

+60 −36
Original line number Diff line number Diff line
@@ -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);

CRA Git | Maintained and supported by SUSTech CRA and CCSE