2019-06-04 08:11:33 +00:00
|
|
|
// SPDX-License-Identifier: GPL-2.0-only
|
2012-09-06 07:09:11 +00:00
|
|
|
/*
|
|
|
|
* Copyright (C) 2012 Freescale Semiconductor, Inc.
|
|
|
|
*
|
2014-08-28 05:52:24 +00:00
|
|
|
* Copyright (C) 2014 Linaro.
|
|
|
|
* Viresh Kumar <viresh.kumar@linaro.org>
|
2012-09-06 07:09:11 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
|
|
|
|
|
|
|
|
#include <linux/clk.h>
|
2013-09-10 17:59:46 +00:00
|
|
|
#include <linux/cpu.h>
|
2012-09-06 07:09:11 +00:00
|
|
|
#include <linux/cpufreq.h>
|
2013-07-15 13:09:14 +00:00
|
|
|
#include <linux/cpumask.h>
|
2012-09-06 07:09:11 +00:00
|
|
|
#include <linux/err.h>
|
2020-07-27 09:30:47 +00:00
|
|
|
#include <linux/list.h>
|
2012-09-06 07:09:11 +00:00
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/of.h>
|
2013-09-19 21:03:52 +00:00
|
|
|
#include <linux/pm_opp.h>
|
2013-01-30 14:27:49 +00:00
|
|
|
#include <linux/platform_device.h>
|
2012-09-06 07:09:11 +00:00
|
|
|
#include <linux/regulator/consumer.h>
|
|
|
|
#include <linux/slab.h>
|
2013-07-15 13:09:14 +00:00
|
|
|
#include <linux/thermal.h>
|
2012-09-06 07:09:11 +00:00
|
|
|
|
2016-09-09 11:18:08 +00:00
|
|
|
#include "cpufreq-dt.h"
|
|
|
|
|
2014-08-28 05:52:28 +00:00
|
|
|
struct private_data {
|
2020-07-27 09:30:47 +00:00
|
|
|
struct list_head node;
|
|
|
|
|
|
|
|
cpumask_var_t cpus;
|
2014-08-28 05:52:28 +00:00
|
|
|
struct device *cpu_dev;
|
2020-07-27 09:30:47 +00:00
|
|
|
struct opp_table *opp_table;
|
2020-11-06 04:58:43 +00:00
|
|
|
struct cpufreq_frequency_table *freq_table;
|
2018-10-03 10:05:21 +00:00
|
|
|
bool have_static_opps;
|
2014-08-28 05:52:28 +00:00
|
|
|
};
|
2012-09-06 07:09:11 +00:00
|
|
|
|
2020-07-27 09:30:47 +00:00
|
|
|
static LIST_HEAD(priv_list);
|
|
|
|
|
2015-08-07 11:59:16 +00:00
|
|
|
static struct freq_attr *cpufreq_dt_attr[] = {
|
|
|
|
&cpufreq_freq_attr_scaling_available_freqs,
|
|
|
|
NULL, /* Extra space for boost-attr if required */
|
|
|
|
NULL,
|
|
|
|
};
|
|
|
|
|
2020-07-27 09:30:47 +00:00
|
|
|
static struct private_data *cpufreq_dt_find_data(int cpu)
|
|
|
|
{
|
|
|
|
struct private_data *priv;
|
|
|
|
|
|
|
|
list_for_each_entry(priv, &priv_list, node) {
|
|
|
|
if (cpumask_test_cpu(cpu, priv->cpus))
|
|
|
|
return priv;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2014-09-09 14:28:03 +00:00
|
|
|
static int set_target(struct cpufreq_policy *policy, unsigned int index)
|
2012-09-06 07:09:11 +00:00
|
|
|
{
|
2014-08-28 05:52:28 +00:00
|
|
|
struct private_data *priv = policy->driver_data;
|
2017-09-26 16:41:09 +00:00
|
|
|
unsigned long freq = policy->freq_table[index].frequency;
|
2012-09-06 07:09:11 +00:00
|
|
|
|
cpufreq: move invariance setter calls in cpufreq core
To properly scale its per-entity load-tracking signals, the task scheduler
needs to be given a frequency scale factor, i.e. some image of the current
frequency the CPU is running at. Currently, this scale can be computed
either by using counters (APERF/MPERF on x86, AMU on arm64), or by
piggy-backing on the frequency selection done by cpufreq.
For the latter, drivers have to explicitly set the scale factor
themselves, despite it being purely boiler-plate code: the required
information depends entirely on the kind of frequency switch callback
implemented by the driver, i.e. either of: target_index(), target(),
fast_switch() and setpolicy().
The fitness of those callbacks with regard to driving the Frequency
Invariance Engine (FIE) is studied below:
target_index()
==============
Documentation states that the chosen frequency "must be determined by
freq_table[index].frequency". It isn't clear if it *has* to be that
frequency, or if it can use that frequency value to do some computation
that ultimately leads to a different frequency selection. All drivers
go for the former, while the vexpress-spc-cpufreq has an atypical
implementation which is handled separately.
Therefore, the hook works on the assumption the core can use
freq_table[index].frequency.
target()
=======
This has been flagged as deprecated since:
commit 9c0ebcf78fde ("cpufreq: Implement light weight ->target_index() routine")
It also doesn't have that many users:
gx-suspmod.c:439: .target = cpufreq_gx_target,
s3c24xx-cpufreq.c:428: .target = s3c_cpufreq_target,
intel_pstate.c:2528: .target = intel_cpufreq_target,
cppc_cpufreq.c:401: .target = cppc_cpufreq_set_target,
cpufreq-nforce2.c:371: .target = nforce2_target,
sh-cpufreq.c:163: .target = sh_cpufreq_target,
pcc-cpufreq.c:573: .target = pcc_cpufreq_target,
Similarly to the path taken for target_index() calls in the cpufreq core
during a frequency change, all of the drivers above will mark the end of a
frequency change by a call to cpufreq_freq_transition_end().
Therefore, cpufreq_freq_transition_end() can be used as the location for
the arch_set_freq_scale() call to potentially inform the scheduler of the
frequency change.
This change maintains the previous functionality for the drivers that
implement the target_index() callback, while also adding support for the
few drivers that implement the deprecated target() callback.
fast_switch()
=============
This callback *has* to return the frequency that was selected.
setpolicy()
===========
This callback does not have any designated way of informing what was the
end choice. But there are only two drivers using setpolicy(), and none
of them have current FIE support:
drivers/cpufreq/longrun.c:281: .setpolicy = longrun_set_policy,
drivers/cpufreq/intel_pstate.c:2215: .setpolicy = intel_pstate_set_policy,
The intel_pstate is known to use counter-driven frequency invariance.
Conclusion
==========
Given that the significant majority of current FIE enabled drivers use
callbacks that lend themselves to triggering the setting of the FIE scale
factor in a generic way, move the invariance setter calls to cpufreq core.
As a result of setting the frequency scale factor in cpufreq core, after
callbacks that lend themselves to trigger it, remove this functionality
from the driver side.
To be noted that despite marking a successful frequency change, many
cpufreq drivers will consider the new frequency as the requested
frequency, although this is might not be the one granted by the hardware.
Therefore, the call to arch_set_freq_scale() is a "best effort" one, and
it is up to the architecture if the new frequency is used in the new
frequency scale factor setting (determined by the implementation of
arch_set_freq_scale()) or eventually used by the scheduler (determined
by the implementation of arch_scale_freq_capacity()). The architecture
is in a better position to decide if it has better methods to obtain
more accurate information regarding the current frequency and use that
information instead (for example, the use of counters).
Also, the implementation to arch_set_freq_scale() will now have to handle
error conditions (current frequency == 0) in order to prevent the
overhead in cpufreq core when the default arch_set_freq_scale()
implementation is used.
Signed-off-by: Ionela Voinescu <ionela.voinescu@arm.com>
Suggested-by: Valentin Schneider <valentin.schneider@arm.com>
Acked-by: Viresh Kumar <viresh.kumar@linaro.org>
Acked-by: Sudeep Holla <sudeep.holla@arm.com>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2020-09-01 20:55:46 +00:00
|
|
|
return dev_pm_opp_set_rate(priv->cpu_dev, freq * 1000);
|
2012-09-06 07:09:11 +00:00
|
|
|
}
|
|
|
|
|
2016-02-09 05:00:43 +00:00
|
|
|
/*
|
|
|
|
* An earlier version of opp-v1 bindings used to name the regulator
|
|
|
|
* "cpu0-supply", we still need to handle that for backwards compatibility.
|
|
|
|
*/
|
2016-02-09 05:00:47 +00:00
|
|
|
static const char *find_supply_name(struct device *dev)
|
2016-02-09 05:00:43 +00:00
|
|
|
{
|
2016-02-09 05:00:47 +00:00
|
|
|
struct device_node *np;
|
2016-02-09 05:00:43 +00:00
|
|
|
struct property *pp;
|
|
|
|
int cpu = dev->id;
|
2016-02-09 05:00:47 +00:00
|
|
|
const char *name = NULL;
|
|
|
|
|
|
|
|
np = of_node_get(dev->of_node);
|
|
|
|
|
|
|
|
/* This must be valid for sure */
|
|
|
|
if (WARN_ON(!np))
|
|
|
|
return NULL;
|
2016-02-09 05:00:43 +00:00
|
|
|
|
|
|
|
/* Try "cpu0" for older DTs */
|
|
|
|
if (!cpu) {
|
|
|
|
pp = of_find_property(np, "cpu0-supply", NULL);
|
2016-02-09 05:00:47 +00:00
|
|
|
if (pp) {
|
|
|
|
name = "cpu0";
|
|
|
|
goto node_put;
|
|
|
|
}
|
2016-02-09 05:00:43 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
pp = of_find_property(np, "cpu-supply", NULL);
|
2016-02-09 05:00:47 +00:00
|
|
|
if (pp) {
|
|
|
|
name = "cpu";
|
|
|
|
goto node_put;
|
|
|
|
}
|
2016-02-09 05:00:43 +00:00
|
|
|
|
|
|
|
dev_dbg(dev, "no regulator for cpu%d\n", cpu);
|
2016-02-09 05:00:47 +00:00
|
|
|
node_put:
|
|
|
|
of_node_put(np);
|
|
|
|
return name;
|
2016-02-09 05:00:43 +00:00
|
|
|
}
|
|
|
|
|
2014-09-09 14:28:03 +00:00
|
|
|
static int cpufreq_init(struct cpufreq_policy *policy)
|
2014-08-28 05:52:28 +00:00
|
|
|
{
|
|
|
|
struct private_data *priv;
|
|
|
|
struct device *cpu_dev;
|
|
|
|
struct clk *cpu_clk;
|
|
|
|
unsigned int transition_latency;
|
|
|
|
int ret;
|
|
|
|
|
2020-07-27 09:30:47 +00:00
|
|
|
priv = cpufreq_dt_find_data(policy->cpu);
|
|
|
|
if (!priv) {
|
|
|
|
pr_err("failed to find data for cpu%d\n", policy->cpu);
|
2016-02-09 05:00:48 +00:00
|
|
|
return -ENODEV;
|
|
|
|
}
|
2020-07-27 09:30:47 +00:00
|
|
|
cpu_dev = priv->cpu_dev;
|
|
|
|
|
2016-02-09 05:00:48 +00:00
|
|
|
cpu_clk = clk_get(cpu_dev, NULL);
|
|
|
|
if (IS_ERR(cpu_clk)) {
|
|
|
|
ret = PTR_ERR(cpu_clk);
|
|
|
|
dev_err(cpu_dev, "%s: failed to get clk: %d\n", __func__, ret);
|
2014-08-28 05:52:28 +00:00
|
|
|
return ret;
|
|
|
|
}
|
2014-08-28 05:52:26 +00:00
|
|
|
|
2020-11-06 04:58:43 +00:00
|
|
|
transition_latency = dev_pm_opp_get_max_transition_latency(cpu_dev);
|
|
|
|
if (!transition_latency)
|
|
|
|
transition_latency = CPUFREQ_ETERNAL;
|
2014-10-24 13:05:55 +00:00
|
|
|
|
2020-11-06 04:58:43 +00:00
|
|
|
cpumask_copy(policy->cpus, priv->cpus);
|
2014-08-28 05:52:28 +00:00
|
|
|
policy->driver_data = priv;
|
|
|
|
policy->clk = cpu_clk;
|
2020-11-06 04:58:43 +00:00
|
|
|
policy->freq_table = priv->freq_table;
|
2017-01-02 09:11:02 +00:00
|
|
|
policy->suspend_freq = dev_pm_opp_get_suspend_opp_freq(cpu_dev) / 1000;
|
2020-11-06 04:58:43 +00:00
|
|
|
policy->cpuinfo.transition_latency = transition_latency;
|
|
|
|
policy->dvfs_possible_from_any_cpu = true;
|
2015-09-08 16:41:03 +00:00
|
|
|
|
2015-07-29 10:53:11 +00:00
|
|
|
/* Support turbo/boost mode */
|
|
|
|
if (policy_has_boost_freq(policy)) {
|
|
|
|
/* This gets disabled by core on driver unregister */
|
|
|
|
ret = cpufreq_enable_boost_support();
|
|
|
|
if (ret)
|
2020-11-06 04:58:43 +00:00
|
|
|
goto out_clk_put;
|
2015-08-07 11:59:16 +00:00
|
|
|
cpufreq_dt_attr[1] = &cpufreq_freq_attr_scaling_boost_freqs;
|
2014-10-19 09:30:28 +00:00
|
|
|
}
|
|
|
|
|
2020-05-27 09:58:54 +00:00
|
|
|
dev_pm_opp_of_register_em(cpu_dev, policy->cpus);
|
2019-02-04 11:09:49 +00:00
|
|
|
|
2012-09-06 07:09:11 +00:00
|
|
|
return 0;
|
|
|
|
|
2020-11-06 04:58:43 +00:00
|
|
|
out_clk_put:
|
2014-08-28 05:52:25 +00:00
|
|
|
clk_put(cpu_clk);
|
2014-08-28 05:52:28 +00:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2019-02-12 07:06:47 +00:00
|
|
|
static int cpufreq_online(struct cpufreq_policy *policy)
|
|
|
|
{
|
|
|
|
/* We did light-weight tear down earlier, nothing to do here */
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int cpufreq_offline(struct cpufreq_policy *policy)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* Preserve policy->driver_data and don't free resources on light-weight
|
|
|
|
* tear down.
|
|
|
|
*/
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-09-09 14:28:03 +00:00
|
|
|
static int cpufreq_exit(struct cpufreq_policy *policy)
|
2014-08-28 05:52:28 +00:00
|
|
|
{
|
|
|
|
clk_put(policy->clk);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-09-09 14:28:03 +00:00
|
|
|
static struct cpufreq_driver dt_cpufreq_driver = {
|
2021-02-02 04:55:11 +00:00
|
|
|
.flags = CPUFREQ_NEED_INITIAL_FREQ_CHECK |
|
2019-01-29 04:55:11 +00:00
|
|
|
CPUFREQ_IS_COOLING_DEV,
|
2014-08-28 05:52:28 +00:00
|
|
|
.verify = cpufreq_generic_frequency_table_verify,
|
2014-09-09 14:28:03 +00:00
|
|
|
.target_index = set_target,
|
2014-08-28 05:52:28 +00:00
|
|
|
.get = cpufreq_generic_get,
|
2014-09-09 14:28:03 +00:00
|
|
|
.init = cpufreq_init,
|
|
|
|
.exit = cpufreq_exit,
|
2019-02-12 07:06:47 +00:00
|
|
|
.online = cpufreq_online,
|
|
|
|
.offline = cpufreq_offline,
|
2014-09-09 14:28:03 +00:00
|
|
|
.name = "cpufreq-dt",
|
2015-08-07 11:59:16 +00:00
|
|
|
.attr = cpufreq_dt_attr,
|
2015-09-08 16:41:03 +00:00
|
|
|
.suspend = cpufreq_generic_suspend,
|
2014-08-28 05:52:28 +00:00
|
|
|
};
|
|
|
|
|
2020-07-27 09:30:47 +00:00
|
|
|
static int dt_cpufreq_early_init(struct device *dev, int cpu)
|
2014-08-28 05:52:28 +00:00
|
|
|
{
|
2020-07-27 09:30:47 +00:00
|
|
|
struct private_data *priv;
|
|
|
|
struct device *cpu_dev;
|
2020-11-06 04:58:43 +00:00
|
|
|
bool fallback = false;
|
2020-07-27 09:30:47 +00:00
|
|
|
const char *reg_name;
|
2014-08-28 05:52:28 +00:00
|
|
|
int ret;
|
|
|
|
|
2020-07-27 09:30:47 +00:00
|
|
|
/* Check if this CPU is already covered by some other policy */
|
|
|
|
if (cpufreq_dt_find_data(cpu))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
cpu_dev = get_cpu_device(cpu);
|
|
|
|
if (!cpu_dev)
|
|
|
|
return -EPROBE_DEFER;
|
|
|
|
|
|
|
|
priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
|
|
|
|
if (!priv)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
if (!alloc_cpumask_var(&priv->cpus, GFP_KERNEL))
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2020-11-06 04:58:43 +00:00
|
|
|
cpumask_set_cpu(cpu, priv->cpus);
|
2020-07-27 09:30:47 +00:00
|
|
|
priv->cpu_dev = cpu_dev;
|
|
|
|
|
2014-08-28 05:52:28 +00:00
|
|
|
/*
|
2020-07-27 09:30:47 +00:00
|
|
|
* OPP layer will be taking care of regulators now, but it needs to know
|
|
|
|
* the name of the regulator first.
|
2014-08-28 05:52:28 +00:00
|
|
|
*/
|
2020-07-27 09:30:47 +00:00
|
|
|
reg_name = find_supply_name(cpu_dev);
|
|
|
|
if (reg_name) {
|
2020-11-06 04:58:43 +00:00
|
|
|
priv->opp_table = dev_pm_opp_set_regulators(cpu_dev, ®_name,
|
|
|
|
1);
|
|
|
|
if (IS_ERR(priv->opp_table)) {
|
|
|
|
ret = PTR_ERR(priv->opp_table);
|
2020-07-27 09:30:47 +00:00
|
|
|
if (ret != -EPROBE_DEFER)
|
|
|
|
dev_err(cpu_dev, "failed to set regulators: %d\n",
|
|
|
|
ret);
|
2020-11-06 04:58:43 +00:00
|
|
|
goto free_cpumask;
|
2020-07-27 09:30:47 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Get OPP-sharing information from "operating-points-v2" bindings */
|
|
|
|
ret = dev_pm_opp_of_get_sharing_cpus(cpu_dev, priv->cpus);
|
|
|
|
if (ret) {
|
|
|
|
if (ret != -ENOENT)
|
2020-11-06 04:58:43 +00:00
|
|
|
goto out;
|
2020-07-27 09:30:47 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* operating-points-v2 not supported, fallback to all CPUs share
|
|
|
|
* OPP for backward compatibility if the platform hasn't set
|
|
|
|
* sharing CPUs.
|
|
|
|
*/
|
2020-11-06 04:58:43 +00:00
|
|
|
if (dev_pm_opp_get_sharing_cpus(cpu_dev, priv->cpus))
|
|
|
|
fallback = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Initialize OPP tables for all priv->cpus. They will be shared by
|
|
|
|
* all CPUs which have marked their CPUs shared with OPP bindings.
|
|
|
|
*
|
|
|
|
* For platforms not using operating-points-v2 bindings, we do this
|
|
|
|
* before updating priv->cpus. Otherwise, we will end up creating
|
|
|
|
* duplicate OPPs for the CPUs.
|
|
|
|
*
|
2021-03-25 06:42:08 +00:00
|
|
|
* OPPs might be populated at runtime, don't fail for error here unless
|
|
|
|
* it is -EPROBE_DEFER.
|
2020-11-06 04:58:43 +00:00
|
|
|
*/
|
2021-03-25 06:42:08 +00:00
|
|
|
ret = dev_pm_opp_of_cpumask_add_table(priv->cpus);
|
|
|
|
if (!ret) {
|
2020-11-06 04:58:43 +00:00
|
|
|
priv->have_static_opps = true;
|
2021-03-25 06:42:08 +00:00
|
|
|
} else if (ret == -EPROBE_DEFER) {
|
|
|
|
goto out;
|
|
|
|
}
|
2020-11-06 04:58:43 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* The OPP table must be initialized, statically or dynamically, by this
|
|
|
|
* point.
|
|
|
|
*/
|
|
|
|
ret = dev_pm_opp_get_opp_count(cpu_dev);
|
|
|
|
if (ret <= 0) {
|
|
|
|
dev_err(cpu_dev, "OPP table can't be empty\n");
|
|
|
|
ret = -ENODEV;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (fallback) {
|
|
|
|
cpumask_setall(priv->cpus);
|
|
|
|
ret = dev_pm_opp_set_sharing_cpus(cpu_dev, priv->cpus);
|
|
|
|
if (ret)
|
|
|
|
dev_err(cpu_dev, "%s: failed to mark OPPs as shared: %d\n",
|
|
|
|
__func__, ret);
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = dev_pm_opp_init_cpufreq_table(cpu_dev, &priv->freq_table);
|
|
|
|
if (ret) {
|
|
|
|
dev_err(cpu_dev, "failed to init cpufreq table: %d\n", ret);
|
|
|
|
goto out;
|
2020-07-27 09:30:47 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
list_add(&priv->node, &priv_list);
|
|
|
|
return 0;
|
|
|
|
|
2020-11-06 04:58:43 +00:00
|
|
|
out:
|
|
|
|
if (priv->have_static_opps)
|
|
|
|
dev_pm_opp_of_cpumask_remove_table(priv->cpus);
|
2020-11-06 06:48:39 +00:00
|
|
|
dev_pm_opp_put_regulators(priv->opp_table);
|
2020-07-27 09:30:47 +00:00
|
|
|
free_cpumask:
|
|
|
|
free_cpumask_var(priv->cpus);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void dt_cpufreq_release(void)
|
|
|
|
{
|
|
|
|
struct private_data *priv, *tmp;
|
|
|
|
|
|
|
|
list_for_each_entry_safe(priv, tmp, &priv_list, node) {
|
2020-11-06 04:58:43 +00:00
|
|
|
dev_pm_opp_free_cpufreq_table(priv->cpu_dev, &priv->freq_table);
|
|
|
|
if (priv->have_static_opps)
|
|
|
|
dev_pm_opp_of_cpumask_remove_table(priv->cpus);
|
2020-11-06 06:48:39 +00:00
|
|
|
dev_pm_opp_put_regulators(priv->opp_table);
|
2020-07-27 09:30:47 +00:00
|
|
|
free_cpumask_var(priv->cpus);
|
|
|
|
list_del(&priv->node);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int dt_cpufreq_probe(struct platform_device *pdev)
|
|
|
|
{
|
|
|
|
struct cpufreq_dt_platform_data *data = dev_get_platdata(&pdev->dev);
|
|
|
|
int ret, cpu;
|
|
|
|
|
|
|
|
/* Request resources early so we can return in case of -EPROBE_DEFER */
|
|
|
|
for_each_possible_cpu(cpu) {
|
|
|
|
ret = dt_cpufreq_early_init(&pdev->dev, cpu);
|
|
|
|
if (ret)
|
|
|
|
goto err;
|
|
|
|
}
|
2014-08-28 05:52:28 +00:00
|
|
|
|
2018-04-24 09:39:45 +00:00
|
|
|
if (data) {
|
|
|
|
if (data->have_governor_per_policy)
|
|
|
|
dt_cpufreq_driver.flags |= CPUFREQ_HAVE_GOVERNOR_PER_POLICY;
|
|
|
|
|
|
|
|
dt_cpufreq_driver.resume = data->resume;
|
|
|
|
if (data->suspend)
|
|
|
|
dt_cpufreq_driver.suspend = data->suspend;
|
2020-02-19 07:59:53 +00:00
|
|
|
if (data->get_intermediate) {
|
|
|
|
dt_cpufreq_driver.target_intermediate = data->target_intermediate;
|
|
|
|
dt_cpufreq_driver.get_intermediate = data->get_intermediate;
|
|
|
|
}
|
2018-04-24 09:39:45 +00:00
|
|
|
}
|
2016-09-09 11:18:08 +00:00
|
|
|
|
2014-09-09 14:28:03 +00:00
|
|
|
ret = cpufreq_register_driver(&dt_cpufreq_driver);
|
2020-07-27 09:30:47 +00:00
|
|
|
if (ret) {
|
2016-02-09 05:00:48 +00:00
|
|
|
dev_err(&pdev->dev, "failed register driver: %d\n", ret);
|
2020-07-27 09:30:47 +00:00
|
|
|
goto err;
|
|
|
|
}
|
2014-08-28 05:52:28 +00:00
|
|
|
|
2020-07-27 09:30:47 +00:00
|
|
|
return 0;
|
|
|
|
err:
|
|
|
|
dt_cpufreq_release();
|
2012-09-06 07:09:11 +00:00
|
|
|
return ret;
|
|
|
|
}
|
2013-01-30 14:27:49 +00:00
|
|
|
|
2014-09-09 14:28:03 +00:00
|
|
|
static int dt_cpufreq_remove(struct platform_device *pdev)
|
2013-01-30 14:27:49 +00:00
|
|
|
{
|
2014-09-09 14:28:03 +00:00
|
|
|
cpufreq_unregister_driver(&dt_cpufreq_driver);
|
2020-07-27 09:30:47 +00:00
|
|
|
dt_cpufreq_release();
|
2013-01-30 14:27:49 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-09-09 14:28:03 +00:00
|
|
|
static struct platform_driver dt_cpufreq_platdrv = {
|
2013-01-30 14:27:49 +00:00
|
|
|
.driver = {
|
2014-09-09 14:28:03 +00:00
|
|
|
.name = "cpufreq-dt",
|
2013-01-30 14:27:49 +00:00
|
|
|
},
|
2014-09-09 14:28:03 +00:00
|
|
|
.probe = dt_cpufreq_probe,
|
|
|
|
.remove = dt_cpufreq_remove,
|
2013-01-30 14:27:49 +00:00
|
|
|
};
|
2014-09-09 14:28:03 +00:00
|
|
|
module_platform_driver(dt_cpufreq_platdrv);
|
2012-09-06 07:09:11 +00:00
|
|
|
|
2015-05-08 19:57:30 +00:00
|
|
|
MODULE_ALIAS("platform:cpufreq-dt");
|
2014-08-28 05:52:24 +00:00
|
|
|
MODULE_AUTHOR("Viresh Kumar <viresh.kumar@linaro.org>");
|
2012-09-06 07:09:11 +00:00
|
|
|
MODULE_AUTHOR("Shawn Guo <shawn.guo@linaro.org>");
|
2014-09-09 14:28:03 +00:00
|
|
|
MODULE_DESCRIPTION("Generic cpufreq driver");
|
2012-09-06 07:09:11 +00:00
|
|
|
MODULE_LICENSE("GPL");
|