2019-06-04 16:11:33 +08:00
|
|
|
// SPDX-License-Identifier: GPL-2.0-only
|
2012-09-06 15:09:11 +08:00
|
|
|
/*
|
|
|
|
* Copyright (C) 2012 Freescale Semiconductor, Inc.
|
|
|
|
*
|
2014-08-28 13:52:24 +08:00
|
|
|
* Copyright (C) 2014 Linaro.
|
|
|
|
* Viresh Kumar <viresh.kumar@linaro.org>
|
2012-09-06 15:09:11 +08:00
|
|
|
*/
|
|
|
|
|
|
|
|
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
|
|
|
|
|
|
|
|
#include <linux/clk.h>
|
2013-09-11 01:59:46 +08:00
|
|
|
#include <linux/cpu.h>
|
2012-09-06 15:09:11 +08:00
|
|
|
#include <linux/cpufreq.h>
|
2013-07-15 21:09:14 +08:00
|
|
|
#include <linux/cpumask.h>
|
2012-09-06 15:09:11 +08:00
|
|
|
#include <linux/err.h>
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/of.h>
|
2013-09-20 05:03:52 +08:00
|
|
|
#include <linux/pm_opp.h>
|
2013-01-30 22:27:49 +08:00
|
|
|
#include <linux/platform_device.h>
|
2012-09-06 15:09:11 +08:00
|
|
|
#include <linux/regulator/consumer.h>
|
|
|
|
#include <linux/slab.h>
|
2013-07-15 21:09:14 +08:00
|
|
|
#include <linux/thermal.h>
|
2012-09-06 15:09:11 +08:00
|
|
|
|
2016-09-09 19:18:08 +08:00
|
|
|
#include "cpufreq-dt.h"
|
|
|
|
|
2014-08-28 13:52:28 +08:00
|
|
|
struct private_data {
|
2016-11-30 18:51:25 +08:00
|
|
|
struct opp_table *opp_table;
|
2014-08-28 13:52:28 +08:00
|
|
|
struct device *cpu_dev;
|
2016-02-09 13:00:43 +08:00
|
|
|
const char *reg_name;
|
2018-10-03 18:05:21 +08:00
|
|
|
bool have_static_opps;
|
2014-08-28 13:52:28 +08:00
|
|
|
};
|
2012-09-06 15:09:11 +08:00
|
|
|
|
2015-08-07 19:59:16 +08:00
|
|
|
static struct freq_attr *cpufreq_dt_attr[] = {
|
|
|
|
&cpufreq_freq_attr_scaling_available_freqs,
|
|
|
|
NULL, /* Extra space for boost-attr if required */
|
|
|
|
NULL,
|
|
|
|
};
|
|
|
|
|
2014-09-09 22:28:03 +08:00
|
|
|
static int set_target(struct cpufreq_policy *policy, unsigned int index)
|
2012-09-06 15:09:11 +08:00
|
|
|
{
|
2014-08-28 13:52:28 +08:00
|
|
|
struct private_data *priv = policy->driver_data;
|
2017-09-27 00:41:09 +08:00
|
|
|
unsigned long freq = policy->freq_table[index].frequency;
|
|
|
|
int ret;
|
2012-09-06 15:09:11 +08:00
|
|
|
|
2017-09-27 00:41:09 +08:00
|
|
|
ret = dev_pm_opp_set_rate(priv->cpu_dev, freq * 1000);
|
|
|
|
|
|
|
|
if (!ret) {
|
|
|
|
arch_set_freq_scale(policy->related_cpus, freq,
|
|
|
|
policy->cpuinfo.max_freq);
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
2012-09-06 15:09:11 +08:00
|
|
|
}
|
|
|
|
|
2016-02-09 13:00:43 +08: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 13:00:47 +08:00
|
|
|
static const char *find_supply_name(struct device *dev)
|
2016-02-09 13:00:43 +08:00
|
|
|
{
|
2016-02-09 13:00:47 +08:00
|
|
|
struct device_node *np;
|
2016-02-09 13:00:43 +08:00
|
|
|
struct property *pp;
|
|
|
|
int cpu = dev->id;
|
2016-02-09 13:00:47 +08: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 13:00:43 +08:00
|
|
|
|
|
|
|
/* Try "cpu0" for older DTs */
|
|
|
|
if (!cpu) {
|
|
|
|
pp = of_find_property(np, "cpu0-supply", NULL);
|
2016-02-09 13:00:47 +08:00
|
|
|
if (pp) {
|
|
|
|
name = "cpu0";
|
|
|
|
goto node_put;
|
|
|
|
}
|
2016-02-09 13:00:43 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
pp = of_find_property(np, "cpu-supply", NULL);
|
2016-02-09 13:00:47 +08:00
|
|
|
if (pp) {
|
|
|
|
name = "cpu";
|
|
|
|
goto node_put;
|
|
|
|
}
|
2016-02-09 13:00:43 +08:00
|
|
|
|
|
|
|
dev_dbg(dev, "no regulator for cpu%d\n", cpu);
|
2016-02-09 13:00:47 +08:00
|
|
|
node_put:
|
|
|
|
of_node_put(np);
|
|
|
|
return name;
|
2016-02-09 13:00:43 +08:00
|
|
|
}
|
|
|
|
|
2016-02-09 13:00:48 +08:00
|
|
|
static int resources_available(void)
|
2012-09-06 15:09:11 +08:00
|
|
|
{
|
2014-08-28 13:52:28 +08:00
|
|
|
struct device *cpu_dev;
|
|
|
|
struct regulator *cpu_reg;
|
|
|
|
struct clk *cpu_clk;
|
|
|
|
int ret = 0;
|
2016-02-09 13:00:48 +08:00
|
|
|
const char *name;
|
2012-09-06 15:09:11 +08:00
|
|
|
|
2016-02-09 13:00:48 +08:00
|
|
|
cpu_dev = get_cpu_device(0);
|
2013-09-11 01:59:46 +08:00
|
|
|
if (!cpu_dev) {
|
2016-02-09 13:00:48 +08:00
|
|
|
pr_err("failed to get cpu0 device\n");
|
2013-09-11 01:59:46 +08:00
|
|
|
return -ENODEV;
|
|
|
|
}
|
2013-01-29 00:13:15 +08:00
|
|
|
|
2016-02-09 13:00:48 +08:00
|
|
|
cpu_clk = clk_get(cpu_dev, NULL);
|
|
|
|
ret = PTR_ERR_OR_ZERO(cpu_clk);
|
2016-01-25 23:45:48 +08:00
|
|
|
if (ret) {
|
cpufreq: cpufreq-cpu0: defer probe when regulator is not ready
With commit 1e4b545, regulator_get will now return -EPROBE_DEFER
when the cpu0-supply node is present, but the regulator is not yet
registered.
It is possible for this to occur when the regulator registration
by itself might be defered due to some dependent interface not yet
instantiated. For example: an regulator which uses I2C and GPIO might
need both systems available before proceeding, in this case, the
regulator might defer it's registration.
However, the cpufreq-cpu0 driver assumes that any un-successful
return result is equivalent of failure.
When the regulator_get returns failure other than -EPROBE_DEFER, it
makes sense to assume that supply node is not present and proceed
with the assumption that only clock control is necessary in the
platform.
With this change, we can now handle the following conditions:
a) cpu0-supply binding is not present, regulator_get will return
appropriate error result, resulting in cpufreq-cpu0 driver
controlling just the clock.
b) cpu0-supply binding is present, regulator_get returns
-EPROBE_DEFER, we retry resulting in cpufreq-cpu0 driver
registering later once the regulator is available.
c) cpu0-supply binding is present, regulator_get returns
-EPROBE_DEFER, however, regulator never registers, we retry until
cpufreq-cpu0 driver fails to register pointing at device tree
information bug. However, in this case, the fact that
cpufreq-cpu0 operates with clock only when the DT binding clearly
indicates need of a supply is a bug of it's own.
d) cpu0-supply gets an regulator at probe - cpufreq-cpu0 driver
controls both the clock and regulator
Signed-off-by: Nishanth Menon <nm@ti.com>
Acked-by: Shawn Guo <shawn.guo@linaro.org>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2013-05-01 21:38:12 +08:00
|
|
|
/*
|
2016-02-09 13:00:48 +08:00
|
|
|
* If cpu's clk node is present, but clock is not yet
|
|
|
|
* registered, we should try defering probe.
|
cpufreq: cpufreq-cpu0: defer probe when regulator is not ready
With commit 1e4b545, regulator_get will now return -EPROBE_DEFER
when the cpu0-supply node is present, but the regulator is not yet
registered.
It is possible for this to occur when the regulator registration
by itself might be defered due to some dependent interface not yet
instantiated. For example: an regulator which uses I2C and GPIO might
need both systems available before proceeding, in this case, the
regulator might defer it's registration.
However, the cpufreq-cpu0 driver assumes that any un-successful
return result is equivalent of failure.
When the regulator_get returns failure other than -EPROBE_DEFER, it
makes sense to assume that supply node is not present and proceed
with the assumption that only clock control is necessary in the
platform.
With this change, we can now handle the following conditions:
a) cpu0-supply binding is not present, regulator_get will return
appropriate error result, resulting in cpufreq-cpu0 driver
controlling just the clock.
b) cpu0-supply binding is present, regulator_get returns
-EPROBE_DEFER, we retry resulting in cpufreq-cpu0 driver
registering later once the regulator is available.
c) cpu0-supply binding is present, regulator_get returns
-EPROBE_DEFER, however, regulator never registers, we retry until
cpufreq-cpu0 driver fails to register pointing at device tree
information bug. However, in this case, the fact that
cpufreq-cpu0 operates with clock only when the DT binding clearly
indicates need of a supply is a bug of it's own.
d) cpu0-supply gets an regulator at probe - cpufreq-cpu0 driver
controls both the clock and regulator
Signed-off-by: Nishanth Menon <nm@ti.com>
Acked-by: Shawn Guo <shawn.guo@linaro.org>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2013-05-01 21:38:12 +08:00
|
|
|
*/
|
2016-02-09 13:00:48 +08:00
|
|
|
if (ret == -EPROBE_DEFER)
|
|
|
|
dev_dbg(cpu_dev, "clock not ready, retry\n");
|
|
|
|
else
|
|
|
|
dev_err(cpu_dev, "failed to get clock: %d\n", ret);
|
2014-08-28 13:52:29 +08:00
|
|
|
|
2016-02-09 13:00:48 +08:00
|
|
|
return ret;
|
cpufreq: cpufreq-cpu0: defer probe when regulator is not ready
With commit 1e4b545, regulator_get will now return -EPROBE_DEFER
when the cpu0-supply node is present, but the regulator is not yet
registered.
It is possible for this to occur when the regulator registration
by itself might be defered due to some dependent interface not yet
instantiated. For example: an regulator which uses I2C and GPIO might
need both systems available before proceeding, in this case, the
regulator might defer it's registration.
However, the cpufreq-cpu0 driver assumes that any un-successful
return result is equivalent of failure.
When the regulator_get returns failure other than -EPROBE_DEFER, it
makes sense to assume that supply node is not present and proceed
with the assumption that only clock control is necessary in the
platform.
With this change, we can now handle the following conditions:
a) cpu0-supply binding is not present, regulator_get will return
appropriate error result, resulting in cpufreq-cpu0 driver
controlling just the clock.
b) cpu0-supply binding is present, regulator_get returns
-EPROBE_DEFER, we retry resulting in cpufreq-cpu0 driver
registering later once the regulator is available.
c) cpu0-supply binding is present, regulator_get returns
-EPROBE_DEFER, however, regulator never registers, we retry until
cpufreq-cpu0 driver fails to register pointing at device tree
information bug. However, in this case, the fact that
cpufreq-cpu0 operates with clock only when the DT binding clearly
indicates need of a supply is a bug of it's own.
d) cpu0-supply gets an regulator at probe - cpufreq-cpu0 driver
controls both the clock and regulator
Signed-off-by: Nishanth Menon <nm@ti.com>
Acked-by: Shawn Guo <shawn.guo@linaro.org>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2013-05-01 21:38:12 +08:00
|
|
|
}
|
|
|
|
|
2016-02-09 13:00:48 +08:00
|
|
|
clk_put(cpu_clk);
|
|
|
|
|
|
|
|
name = find_supply_name(cpu_dev);
|
|
|
|
/* Platform doesn't require regulator */
|
|
|
|
if (!name)
|
|
|
|
return 0;
|
2014-08-28 13:52:28 +08:00
|
|
|
|
2016-02-09 13:00:48 +08:00
|
|
|
cpu_reg = regulator_get_optional(cpu_dev, name);
|
|
|
|
ret = PTR_ERR_OR_ZERO(cpu_reg);
|
|
|
|
if (ret) {
|
2014-08-28 13:52:26 +08:00
|
|
|
/*
|
2016-02-09 13:00:48 +08:00
|
|
|
* If cpu's regulator supply node is present, but regulator is
|
|
|
|
* not yet registered, we should try defering probe.
|
2014-08-28 13:52:26 +08:00
|
|
|
*/
|
|
|
|
if (ret == -EPROBE_DEFER)
|
2016-02-09 13:00:48 +08:00
|
|
|
dev_dbg(cpu_dev, "cpu0 regulator not ready, retry\n");
|
2014-08-28 13:52:26 +08:00
|
|
|
else
|
2016-02-09 13:00:48 +08:00
|
|
|
dev_dbg(cpu_dev, "no regulator for cpu0: %d\n", ret);
|
|
|
|
|
|
|
|
return ret;
|
2014-08-28 13:52:28 +08:00
|
|
|
}
|
|
|
|
|
2016-02-09 13:00:48 +08:00
|
|
|
regulator_put(cpu_reg);
|
|
|
|
return 0;
|
2014-08-28 13:52:28 +08:00
|
|
|
}
|
|
|
|
|
2014-09-09 22:28:03 +08:00
|
|
|
static int cpufreq_init(struct cpufreq_policy *policy)
|
2014-08-28 13:52:28 +08:00
|
|
|
{
|
|
|
|
struct cpufreq_frequency_table *freq_table;
|
2016-11-30 18:51:25 +08:00
|
|
|
struct opp_table *opp_table = NULL;
|
2014-08-28 13:52:28 +08:00
|
|
|
struct private_data *priv;
|
|
|
|
struct device *cpu_dev;
|
|
|
|
struct clk *cpu_clk;
|
|
|
|
unsigned int transition_latency;
|
2016-04-27 11:22:24 +08:00
|
|
|
bool fallback = false;
|
2016-02-09 13:00:43 +08:00
|
|
|
const char *name;
|
2014-08-28 13:52:28 +08:00
|
|
|
int ret;
|
|
|
|
|
2016-02-09 13:00:48 +08:00
|
|
|
cpu_dev = get_cpu_device(policy->cpu);
|
|
|
|
if (!cpu_dev) {
|
|
|
|
pr_err("failed to get cpu%d device\n", policy->cpu);
|
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
|
|
|
|
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 13:52:28 +08:00
|
|
|
return ret;
|
|
|
|
}
|
2014-08-28 13:52:26 +08:00
|
|
|
|
2015-07-29 18:53:10 +08:00
|
|
|
/* Get OPP-sharing information from "operating-points-v2" bindings */
|
2015-09-04 16:17:24 +08:00
|
|
|
ret = dev_pm_opp_of_get_sharing_cpus(cpu_dev, policy->cpus);
|
2015-07-29 18:53:10 +08:00
|
|
|
if (ret) {
|
2016-04-27 11:22:24 +08:00
|
|
|
if (ret != -ENOENT)
|
|
|
|
goto out_put_clk;
|
|
|
|
|
2015-07-29 18:53:10 +08:00
|
|
|
/*
|
|
|
|
* operating-points-v2 not supported, fallback to old method of
|
2016-04-27 11:22:24 +08:00
|
|
|
* finding shared-OPPs for backward compatibility if the
|
|
|
|
* platform hasn't set sharing CPUs.
|
2015-07-29 18:53:10 +08:00
|
|
|
*/
|
2016-04-27 11:22:24 +08:00
|
|
|
if (dev_pm_opp_get_sharing_cpus(cpu_dev, policy->cpus))
|
|
|
|
fallback = true;
|
2015-07-29 18:53:10 +08:00
|
|
|
}
|
|
|
|
|
2016-02-09 13:00:43 +08:00
|
|
|
/*
|
|
|
|
* OPP layer will be taking care of regulators now, but it needs to know
|
|
|
|
* the name of the regulator first.
|
|
|
|
*/
|
2016-02-09 13:00:47 +08:00
|
|
|
name = find_supply_name(cpu_dev);
|
2016-02-09 13:00:43 +08:00
|
|
|
if (name) {
|
2016-12-01 18:58:19 +08:00
|
|
|
opp_table = dev_pm_opp_set_regulators(cpu_dev, &name, 1);
|
2016-11-30 18:51:25 +08:00
|
|
|
if (IS_ERR(opp_table)) {
|
|
|
|
ret = PTR_ERR(opp_table);
|
2016-02-09 13:00:43 +08:00
|
|
|
dev_err(cpu_dev, "Failed to set regulator for cpu%d: %d\n",
|
|
|
|
policy->cpu, ret);
|
2016-02-09 13:00:48 +08:00
|
|
|
goto out_put_clk;
|
2016-02-09 13:00:43 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-10-03 18:05:21 +08:00
|
|
|
priv = kzalloc(sizeof(*priv), GFP_KERNEL);
|
|
|
|
if (!priv) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto out_put_regulator;
|
|
|
|
}
|
|
|
|
|
|
|
|
priv->reg_name = name;
|
|
|
|
priv->opp_table = opp_table;
|
|
|
|
|
2015-07-29 18:53:10 +08:00
|
|
|
/*
|
|
|
|
* Initialize OPP tables for all policy->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 policy->cpus. Otherwise, we will end up creating
|
|
|
|
* duplicate OPPs for policy->cpus.
|
|
|
|
*
|
|
|
|
* OPPs might be populated at runtime, don't check for error here
|
|
|
|
*/
|
2018-10-03 18:05:21 +08:00
|
|
|
if (!dev_pm_opp_of_cpumask_add_table(policy->cpus))
|
|
|
|
priv->have_static_opps = true;
|
2015-07-29 18:53:10 +08:00
|
|
|
|
2015-09-02 17:06:48 +08:00
|
|
|
/*
|
|
|
|
* But we need OPP table to function so if it is not there let's
|
|
|
|
* give platform code chance to provide it for us.
|
|
|
|
*/
|
|
|
|
ret = dev_pm_opp_get_opp_count(cpu_dev);
|
|
|
|
if (ret <= 0) {
|
2016-02-09 13:00:40 +08:00
|
|
|
dev_dbg(cpu_dev, "OPP table is not ready, deferring probe\n");
|
2015-09-02 17:06:48 +08:00
|
|
|
ret = -EPROBE_DEFER;
|
|
|
|
goto out_free_opp;
|
|
|
|
}
|
|
|
|
|
2016-04-27 11:22:24 +08:00
|
|
|
if (fallback) {
|
2016-04-27 11:22:26 +08:00
|
|
|
cpumask_setall(policy->cpus);
|
2015-07-29 18:53:10 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* OPP tables are initialized only for policy->cpu, do it for
|
|
|
|
* others as well.
|
|
|
|
*/
|
2015-09-04 16:17:24 +08:00
|
|
|
ret = dev_pm_opp_set_sharing_cpus(cpu_dev, policy->cpus);
|
2015-09-02 17:06:49 +08:00
|
|
|
if (ret)
|
|
|
|
dev_err(cpu_dev, "%s: failed to mark OPPs as shared: %d\n",
|
|
|
|
__func__, ret);
|
2015-07-29 18:53:10 +08:00
|
|
|
}
|
2012-09-06 15:09:11 +08:00
|
|
|
|
2014-10-24 21:05:55 +08:00
|
|
|
ret = dev_pm_opp_init_cpufreq_table(cpu_dev, &freq_table);
|
|
|
|
if (ret) {
|
2016-02-09 13:00:40 +08:00
|
|
|
dev_err(cpu_dev, "failed to init cpufreq table: %d\n", ret);
|
2018-10-03 18:05:21 +08:00
|
|
|
goto out_free_opp;
|
2014-10-24 21:05:55 +08:00
|
|
|
}
|
|
|
|
|
2014-08-28 13:52:28 +08:00
|
|
|
priv->cpu_dev = cpu_dev;
|
|
|
|
policy->driver_data = priv;
|
|
|
|
policy->clk = cpu_clk;
|
2018-02-26 13:08:50 +08:00
|
|
|
policy->freq_table = freq_table;
|
2015-09-09 00:41:03 +08:00
|
|
|
|
2017-01-02 17:11:02 +08:00
|
|
|
policy->suspend_freq = dev_pm_opp_get_suspend_opp_freq(cpu_dev) / 1000;
|
2015-09-09 00:41:03 +08:00
|
|
|
|
2015-07-29 18:53:11 +08: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)
|
|
|
|
goto out_free_cpufreq_table;
|
2015-08-07 19:59:16 +08:00
|
|
|
cpufreq_dt_attr[1] = &cpufreq_freq_attr_scaling_boost_freqs;
|
2014-10-19 17:30:28 +08:00
|
|
|
}
|
|
|
|
|
2016-02-09 13:00:45 +08:00
|
|
|
transition_latency = dev_pm_opp_get_max_transition_latency(cpu_dev);
|
|
|
|
if (!transition_latency)
|
|
|
|
transition_latency = CPUFREQ_ETERNAL;
|
|
|
|
|
2014-10-19 17:30:28 +08:00
|
|
|
policy->cpuinfo.transition_latency = transition_latency;
|
2017-07-28 14:46:39 +08:00
|
|
|
policy->dvfs_possible_from_any_cpu = true;
|
2014-10-19 17:30:28 +08:00
|
|
|
|
2019-02-04 19:09:49 +08:00
|
|
|
dev_pm_opp_of_register_em(policy->cpus);
|
|
|
|
|
2012-09-06 15:09:11 +08:00
|
|
|
return 0;
|
|
|
|
|
2014-11-27 08:37:52 +08:00
|
|
|
out_free_cpufreq_table:
|
2013-09-20 05:03:50 +08:00
|
|
|
dev_pm_opp_free_cpufreq_table(cpu_dev, &freq_table);
|
2014-11-25 18:34:21 +08:00
|
|
|
out_free_opp:
|
2018-10-03 18:05:21 +08:00
|
|
|
if (priv->have_static_opps)
|
|
|
|
dev_pm_opp_of_cpumask_remove_table(policy->cpus);
|
|
|
|
kfree(priv);
|
|
|
|
out_put_regulator:
|
2016-02-09 13:00:43 +08:00
|
|
|
if (name)
|
2016-12-01 18:58:19 +08:00
|
|
|
dev_pm_opp_put_regulators(opp_table);
|
2016-02-09 13:00:48 +08:00
|
|
|
out_put_clk:
|
2014-08-28 13:52:25 +08:00
|
|
|
clk_put(cpu_clk);
|
2014-08-28 13:52:28 +08:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2019-02-12 15:06:47 +08: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 22:28:03 +08:00
|
|
|
static int cpufreq_exit(struct cpufreq_policy *policy)
|
2014-08-28 13:52:28 +08:00
|
|
|
{
|
|
|
|
struct private_data *priv = policy->driver_data;
|
|
|
|
|
|
|
|
dev_pm_opp_free_cpufreq_table(priv->cpu_dev, &policy->freq_table);
|
2018-10-03 18:05:21 +08:00
|
|
|
if (priv->have_static_opps)
|
|
|
|
dev_pm_opp_of_cpumask_remove_table(policy->related_cpus);
|
2016-02-09 13:00:43 +08:00
|
|
|
if (priv->reg_name)
|
2016-12-01 18:58:19 +08:00
|
|
|
dev_pm_opp_put_regulators(priv->opp_table);
|
2016-02-09 13:00:43 +08:00
|
|
|
|
2014-08-28 13:52:28 +08:00
|
|
|
clk_put(policy->clk);
|
|
|
|
kfree(priv);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-09-09 22:28:03 +08:00
|
|
|
static struct cpufreq_driver dt_cpufreq_driver = {
|
2019-01-29 12:55:11 +08:00
|
|
|
.flags = CPUFREQ_STICKY | CPUFREQ_NEED_INITIAL_FREQ_CHECK |
|
|
|
|
CPUFREQ_IS_COOLING_DEV,
|
2014-08-28 13:52:28 +08:00
|
|
|
.verify = cpufreq_generic_frequency_table_verify,
|
2014-09-09 22:28:03 +08:00
|
|
|
.target_index = set_target,
|
2014-08-28 13:52:28 +08:00
|
|
|
.get = cpufreq_generic_get,
|
2014-09-09 22:28:03 +08:00
|
|
|
.init = cpufreq_init,
|
|
|
|
.exit = cpufreq_exit,
|
2019-02-12 15:06:47 +08:00
|
|
|
.online = cpufreq_online,
|
|
|
|
.offline = cpufreq_offline,
|
2014-09-09 22:28:03 +08:00
|
|
|
.name = "cpufreq-dt",
|
2015-08-07 19:59:16 +08:00
|
|
|
.attr = cpufreq_dt_attr,
|
2015-09-09 00:41:03 +08:00
|
|
|
.suspend = cpufreq_generic_suspend,
|
2014-08-28 13:52:28 +08:00
|
|
|
};
|
|
|
|
|
2014-09-09 22:28:03 +08:00
|
|
|
static int dt_cpufreq_probe(struct platform_device *pdev)
|
2014-08-28 13:52:28 +08:00
|
|
|
{
|
2016-09-09 19:18:08 +08:00
|
|
|
struct cpufreq_dt_platform_data *data = dev_get_platdata(&pdev->dev);
|
2014-08-28 13:52:28 +08:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* All per-cluster (CPUs sharing clock/voltages) initialization is done
|
|
|
|
* from ->init(). In probe(), we just need to make sure that clk and
|
|
|
|
* regulators are available. Else defer probe and retry.
|
|
|
|
*
|
|
|
|
* FIXME: Is checking this only for CPU0 sufficient ?
|
|
|
|
*/
|
2016-02-09 13:00:48 +08:00
|
|
|
ret = resources_available();
|
2014-08-28 13:52:28 +08:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
2018-04-24 17:39:45 +08: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 15:59:53 +08:00
|
|
|
if (data->get_intermediate) {
|
|
|
|
dt_cpufreq_driver.target_intermediate = data->target_intermediate;
|
|
|
|
dt_cpufreq_driver.get_intermediate = data->get_intermediate;
|
|
|
|
}
|
2018-04-24 17:39:45 +08:00
|
|
|
}
|
2016-09-09 19:18:08 +08:00
|
|
|
|
2014-09-09 22:28:03 +08:00
|
|
|
ret = cpufreq_register_driver(&dt_cpufreq_driver);
|
2014-08-28 13:52:28 +08:00
|
|
|
if (ret)
|
2016-02-09 13:00:48 +08:00
|
|
|
dev_err(&pdev->dev, "failed register driver: %d\n", ret);
|
2014-08-28 13:52:28 +08:00
|
|
|
|
2012-09-06 15:09:11 +08:00
|
|
|
return ret;
|
|
|
|
}
|
2013-01-30 22:27:49 +08:00
|
|
|
|
2014-09-09 22:28:03 +08:00
|
|
|
static int dt_cpufreq_remove(struct platform_device *pdev)
|
2013-01-30 22:27:49 +08:00
|
|
|
{
|
2014-09-09 22:28:03 +08:00
|
|
|
cpufreq_unregister_driver(&dt_cpufreq_driver);
|
2013-01-30 22:27:49 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-09-09 22:28:03 +08:00
|
|
|
static struct platform_driver dt_cpufreq_platdrv = {
|
2013-01-30 22:27:49 +08:00
|
|
|
.driver = {
|
2014-09-09 22:28:03 +08:00
|
|
|
.name = "cpufreq-dt",
|
2013-01-30 22:27:49 +08:00
|
|
|
},
|
2014-09-09 22:28:03 +08:00
|
|
|
.probe = dt_cpufreq_probe,
|
|
|
|
.remove = dt_cpufreq_remove,
|
2013-01-30 22:27:49 +08:00
|
|
|
};
|
2014-09-09 22:28:03 +08:00
|
|
|
module_platform_driver(dt_cpufreq_platdrv);
|
2012-09-06 15:09:11 +08:00
|
|
|
|
2015-05-09 03:57:30 +08:00
|
|
|
MODULE_ALIAS("platform:cpufreq-dt");
|
2014-08-28 13:52:24 +08:00
|
|
|
MODULE_AUTHOR("Viresh Kumar <viresh.kumar@linaro.org>");
|
2012-09-06 15:09:11 +08:00
|
|
|
MODULE_AUTHOR("Shawn Guo <shawn.guo@linaro.org>");
|
2014-09-09 22:28:03 +08:00
|
|
|
MODULE_DESCRIPTION("Generic cpufreq driver");
|
2012-09-06 15:09:11 +08:00
|
|
|
MODULE_LICENSE("GPL");
|