2012-09-06 14:09:11 +07:00
|
|
|
/*
|
|
|
|
* Copyright (C) 2012 Freescale Semiconductor, Inc.
|
|
|
|
*
|
2014-08-28 12:52:24 +07:00
|
|
|
* Copyright (C) 2014 Linaro.
|
|
|
|
* Viresh Kumar <viresh.kumar@linaro.org>
|
|
|
|
*
|
2012-09-06 14:09:11 +07:00
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License version 2 as
|
|
|
|
* published by the Free Software Foundation.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
|
|
|
|
|
|
|
|
#include <linux/clk.h>
|
2013-09-11 00:59:46 +07:00
|
|
|
#include <linux/cpu.h>
|
2013-07-15 20:09:14 +07:00
|
|
|
#include <linux/cpu_cooling.h>
|
2012-09-06 14:09:11 +07:00
|
|
|
#include <linux/cpufreq.h>
|
2013-07-15 20:09:14 +07:00
|
|
|
#include <linux/cpumask.h>
|
2012-09-06 14:09:11 +07:00
|
|
|
#include <linux/err.h>
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/of.h>
|
2013-09-20 04:03:52 +07:00
|
|
|
#include <linux/pm_opp.h>
|
2013-01-30 21:27:49 +07:00
|
|
|
#include <linux/platform_device.h>
|
2012-09-06 14:09:11 +07:00
|
|
|
#include <linux/regulator/consumer.h>
|
|
|
|
#include <linux/slab.h>
|
2013-07-15 20:09:14 +07:00
|
|
|
#include <linux/thermal.h>
|
2012-09-06 14:09:11 +07:00
|
|
|
|
2016-09-09 18:18:08 +07:00
|
|
|
#include "cpufreq-dt.h"
|
|
|
|
|
2014-08-28 12:52:28 +07:00
|
|
|
struct private_data {
|
2016-11-30 17:51:25 +07:00
|
|
|
struct opp_table *opp_table;
|
2014-08-28 12:52:28 +07:00
|
|
|
struct device *cpu_dev;
|
|
|
|
struct thermal_cooling_device *cdev;
|
2016-02-09 12:00:43 +07:00
|
|
|
const char *reg_name;
|
2014-08-28 12:52:28 +07:00
|
|
|
};
|
2012-09-06 14:09:11 +07:00
|
|
|
|
2015-08-07 18:59:16 +07: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 21:28:03 +07:00
|
|
|
static int set_target(struct cpufreq_policy *policy, unsigned int index)
|
2012-09-06 14:09:11 +07:00
|
|
|
{
|
2014-08-28 12:52:28 +07:00
|
|
|
struct private_data *priv = policy->driver_data;
|
2012-09-06 14:09:11 +07:00
|
|
|
|
2016-02-09 12:00:46 +07:00
|
|
|
return dev_pm_opp_set_rate(priv->cpu_dev,
|
|
|
|
policy->freq_table[index].frequency * 1000);
|
2012-09-06 14:09:11 +07:00
|
|
|
}
|
|
|
|
|
2016-02-09 12:00:43 +07: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 12:00:47 +07:00
|
|
|
static const char *find_supply_name(struct device *dev)
|
2016-02-09 12:00:43 +07:00
|
|
|
{
|
2016-02-09 12:00:47 +07:00
|
|
|
struct device_node *np;
|
2016-02-09 12:00:43 +07:00
|
|
|
struct property *pp;
|
|
|
|
int cpu = dev->id;
|
2016-02-09 12:00:47 +07: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 12:00:43 +07:00
|
|
|
|
|
|
|
/* Try "cpu0" for older DTs */
|
|
|
|
if (!cpu) {
|
|
|
|
pp = of_find_property(np, "cpu0-supply", NULL);
|
2016-02-09 12:00:47 +07:00
|
|
|
if (pp) {
|
|
|
|
name = "cpu0";
|
|
|
|
goto node_put;
|
|
|
|
}
|
2016-02-09 12:00:43 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
pp = of_find_property(np, "cpu-supply", NULL);
|
2016-02-09 12:00:47 +07:00
|
|
|
if (pp) {
|
|
|
|
name = "cpu";
|
|
|
|
goto node_put;
|
|
|
|
}
|
2016-02-09 12:00:43 +07:00
|
|
|
|
|
|
|
dev_dbg(dev, "no regulator for cpu%d\n", cpu);
|
2016-02-09 12:00:47 +07:00
|
|
|
node_put:
|
|
|
|
of_node_put(np);
|
|
|
|
return name;
|
2016-02-09 12:00:43 +07:00
|
|
|
}
|
|
|
|
|
2016-02-09 12:00:48 +07:00
|
|
|
static int resources_available(void)
|
2012-09-06 14:09:11 +07:00
|
|
|
{
|
2014-08-28 12:52:28 +07:00
|
|
|
struct device *cpu_dev;
|
|
|
|
struct regulator *cpu_reg;
|
|
|
|
struct clk *cpu_clk;
|
|
|
|
int ret = 0;
|
2016-02-09 12:00:48 +07:00
|
|
|
const char *name;
|
2012-09-06 14:09:11 +07:00
|
|
|
|
2016-02-09 12:00:48 +07:00
|
|
|
cpu_dev = get_cpu_device(0);
|
2013-09-11 00:59:46 +07:00
|
|
|
if (!cpu_dev) {
|
2016-02-09 12:00:48 +07:00
|
|
|
pr_err("failed to get cpu0 device\n");
|
2013-09-11 00:59:46 +07:00
|
|
|
return -ENODEV;
|
|
|
|
}
|
2013-01-28 23:13:15 +07:00
|
|
|
|
2016-02-09 12:00:48 +07:00
|
|
|
cpu_clk = clk_get(cpu_dev, NULL);
|
|
|
|
ret = PTR_ERR_OR_ZERO(cpu_clk);
|
2016-01-25 22:45:48 +07: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 20:38:12 +07:00
|
|
|
/*
|
2016-02-09 12:00:48 +07: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 20:38:12 +07:00
|
|
|
*/
|
2016-02-09 12:00:48 +07: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 12:52:29 +07:00
|
|
|
|
2016-02-09 12:00:48 +07: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 20:38:12 +07:00
|
|
|
}
|
|
|
|
|
2016-02-09 12:00:48 +07:00
|
|
|
clk_put(cpu_clk);
|
|
|
|
|
|
|
|
name = find_supply_name(cpu_dev);
|
|
|
|
/* Platform doesn't require regulator */
|
|
|
|
if (!name)
|
|
|
|
return 0;
|
2014-08-28 12:52:28 +07:00
|
|
|
|
2016-02-09 12:00:48 +07:00
|
|
|
cpu_reg = regulator_get_optional(cpu_dev, name);
|
|
|
|
ret = PTR_ERR_OR_ZERO(cpu_reg);
|
|
|
|
if (ret) {
|
2014-08-28 12:52:26 +07:00
|
|
|
/*
|
2016-02-09 12:00:48 +07:00
|
|
|
* If cpu's regulator supply node is present, but regulator is
|
|
|
|
* not yet registered, we should try defering probe.
|
2014-08-28 12:52:26 +07:00
|
|
|
*/
|
|
|
|
if (ret == -EPROBE_DEFER)
|
2016-02-09 12:00:48 +07:00
|
|
|
dev_dbg(cpu_dev, "cpu0 regulator not ready, retry\n");
|
2014-08-28 12:52:26 +07:00
|
|
|
else
|
2016-02-09 12:00:48 +07:00
|
|
|
dev_dbg(cpu_dev, "no regulator for cpu0: %d\n", ret);
|
|
|
|
|
|
|
|
return ret;
|
2014-08-28 12:52:28 +07:00
|
|
|
}
|
|
|
|
|
2016-02-09 12:00:48 +07:00
|
|
|
regulator_put(cpu_reg);
|
|
|
|
return 0;
|
2014-08-28 12:52:28 +07:00
|
|
|
}
|
|
|
|
|
2014-09-09 21:28:03 +07:00
|
|
|
static int cpufreq_init(struct cpufreq_policy *policy)
|
2014-08-28 12:52:28 +07:00
|
|
|
{
|
|
|
|
struct cpufreq_frequency_table *freq_table;
|
2016-11-30 17:51:25 +07:00
|
|
|
struct opp_table *opp_table = NULL;
|
2014-08-28 12:52:28 +07:00
|
|
|
struct private_data *priv;
|
|
|
|
struct device *cpu_dev;
|
|
|
|
struct clk *cpu_clk;
|
|
|
|
unsigned int transition_latency;
|
2016-04-27 10:22:24 +07:00
|
|
|
bool fallback = false;
|
2016-02-09 12:00:43 +07:00
|
|
|
const char *name;
|
2014-08-28 12:52:28 +07:00
|
|
|
int ret;
|
|
|
|
|
2016-02-09 12:00:48 +07: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 12:52:28 +07:00
|
|
|
return ret;
|
|
|
|
}
|
2014-08-28 12:52:26 +07:00
|
|
|
|
2015-07-29 17:53:10 +07:00
|
|
|
/* Get OPP-sharing information from "operating-points-v2" bindings */
|
2015-09-04 15:17:24 +07:00
|
|
|
ret = dev_pm_opp_of_get_sharing_cpus(cpu_dev, policy->cpus);
|
2015-07-29 17:53:10 +07:00
|
|
|
if (ret) {
|
2016-04-27 10:22:24 +07:00
|
|
|
if (ret != -ENOENT)
|
|
|
|
goto out_put_clk;
|
|
|
|
|
2015-07-29 17:53:10 +07:00
|
|
|
/*
|
|
|
|
* operating-points-v2 not supported, fallback to old method of
|
2016-04-27 10:22:24 +07:00
|
|
|
* finding shared-OPPs for backward compatibility if the
|
|
|
|
* platform hasn't set sharing CPUs.
|
2015-07-29 17:53:10 +07:00
|
|
|
*/
|
2016-04-27 10:22:24 +07:00
|
|
|
if (dev_pm_opp_get_sharing_cpus(cpu_dev, policy->cpus))
|
|
|
|
fallback = true;
|
2015-07-29 17:53:10 +07:00
|
|
|
}
|
|
|
|
|
2016-02-09 12:00:43 +07:00
|
|
|
/*
|
|
|
|
* OPP layer will be taking care of regulators now, but it needs to know
|
|
|
|
* the name of the regulator first.
|
|
|
|
*/
|
2016-02-09 12:00:47 +07:00
|
|
|
name = find_supply_name(cpu_dev);
|
2016-02-09 12:00:43 +07:00
|
|
|
if (name) {
|
2016-12-01 17:58:19 +07:00
|
|
|
opp_table = dev_pm_opp_set_regulators(cpu_dev, &name, 1);
|
2016-11-30 17:51:25 +07:00
|
|
|
if (IS_ERR(opp_table)) {
|
|
|
|
ret = PTR_ERR(opp_table);
|
2016-02-09 12:00:43 +07:00
|
|
|
dev_err(cpu_dev, "Failed to set regulator for cpu%d: %d\n",
|
|
|
|
policy->cpu, ret);
|
2016-02-09 12:00:48 +07:00
|
|
|
goto out_put_clk;
|
2016-02-09 12:00:43 +07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-07-29 17:53:10 +07: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
|
|
|
|
*/
|
2015-09-04 15:17:24 +07:00
|
|
|
dev_pm_opp_of_cpumask_add_table(policy->cpus);
|
2015-07-29 17:53:10 +07:00
|
|
|
|
2015-09-02 16:06:48 +07: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 12:00:40 +07:00
|
|
|
dev_dbg(cpu_dev, "OPP table is not ready, deferring probe\n");
|
2015-09-02 16:06:48 +07:00
|
|
|
ret = -EPROBE_DEFER;
|
|
|
|
goto out_free_opp;
|
|
|
|
}
|
|
|
|
|
2016-04-27 10:22:24 +07:00
|
|
|
if (fallback) {
|
2016-04-27 10:22:26 +07:00
|
|
|
cpumask_setall(policy->cpus);
|
2015-07-29 17:53:10 +07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* OPP tables are initialized only for policy->cpu, do it for
|
|
|
|
* others as well.
|
|
|
|
*/
|
2015-09-04 15:17:24 +07:00
|
|
|
ret = dev_pm_opp_set_sharing_cpus(cpu_dev, policy->cpus);
|
2015-09-02 16:06:49 +07:00
|
|
|
if (ret)
|
|
|
|
dev_err(cpu_dev, "%s: failed to mark OPPs as shared: %d\n",
|
|
|
|
__func__, ret);
|
2015-07-29 17:53:10 +07:00
|
|
|
}
|
2012-09-06 14:09:11 +07:00
|
|
|
|
2014-08-28 12:52:28 +07:00
|
|
|
priv = kzalloc(sizeof(*priv), GFP_KERNEL);
|
|
|
|
if (!priv) {
|
|
|
|
ret = -ENOMEM;
|
2014-11-25 17:34:21 +07:00
|
|
|
goto out_free_opp;
|
2012-09-06 14:09:11 +07:00
|
|
|
}
|
|
|
|
|
2016-02-09 12:00:43 +07:00
|
|
|
priv->reg_name = name;
|
2016-11-30 17:51:25 +07:00
|
|
|
priv->opp_table = opp_table;
|
2012-09-06 14:09:11 +07:00
|
|
|
|
2014-10-24 20:05:55 +07:00
|
|
|
ret = dev_pm_opp_init_cpufreq_table(cpu_dev, &freq_table);
|
|
|
|
if (ret) {
|
2016-02-09 12:00:40 +07:00
|
|
|
dev_err(cpu_dev, "failed to init cpufreq table: %d\n", ret);
|
2014-10-24 20:05:55 +07:00
|
|
|
goto out_free_priv;
|
|
|
|
}
|
|
|
|
|
2014-08-28 12:52:28 +07:00
|
|
|
priv->cpu_dev = cpu_dev;
|
|
|
|
policy->driver_data = priv;
|
|
|
|
policy->clk = cpu_clk;
|
2015-09-08 23:41:03 +07:00
|
|
|
|
2017-01-02 16:11:02 +07:00
|
|
|
policy->suspend_freq = dev_pm_opp_get_suspend_opp_freq(cpu_dev) / 1000;
|
2015-09-08 23:41:03 +07:00
|
|
|
|
2014-10-19 16:30:28 +07:00
|
|
|
ret = cpufreq_table_validate_and_show(policy, freq_table);
|
|
|
|
if (ret) {
|
|
|
|
dev_err(cpu_dev, "%s: invalid frequency table: %d\n", __func__,
|
|
|
|
ret);
|
2014-11-27 07:37:52 +07:00
|
|
|
goto out_free_cpufreq_table;
|
2015-07-29 17:53:11 +07: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 18:59:16 +07:00
|
|
|
cpufreq_dt_attr[1] = &cpufreq_freq_attr_scaling_boost_freqs;
|
2014-10-19 16:30:28 +07:00
|
|
|
}
|
|
|
|
|
2016-02-09 12:00:45 +07:00
|
|
|
transition_latency = dev_pm_opp_get_max_transition_latency(cpu_dev);
|
|
|
|
if (!transition_latency)
|
|
|
|
transition_latency = CPUFREQ_ETERNAL;
|
|
|
|
|
2014-10-19 16:30:28 +07:00
|
|
|
policy->cpuinfo.transition_latency = transition_latency;
|
|
|
|
|
2012-09-06 14:09:11 +07:00
|
|
|
return 0;
|
|
|
|
|
2014-11-27 07:37:52 +07:00
|
|
|
out_free_cpufreq_table:
|
2013-09-20 04:03:50 +07:00
|
|
|
dev_pm_opp_free_cpufreq_table(cpu_dev, &freq_table);
|
2014-10-24 20:05:55 +07:00
|
|
|
out_free_priv:
|
|
|
|
kfree(priv);
|
2014-11-25 17:34:21 +07:00
|
|
|
out_free_opp:
|
2015-09-04 15:17:24 +07:00
|
|
|
dev_pm_opp_of_cpumask_remove_table(policy->cpus);
|
2016-02-09 12:00:43 +07:00
|
|
|
if (name)
|
2016-12-01 17:58:19 +07:00
|
|
|
dev_pm_opp_put_regulators(opp_table);
|
2016-02-09 12:00:48 +07:00
|
|
|
out_put_clk:
|
2014-08-28 12:52:25 +07:00
|
|
|
clk_put(cpu_clk);
|
2014-08-28 12:52:28 +07:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2014-09-09 21:28:03 +07:00
|
|
|
static int cpufreq_exit(struct cpufreq_policy *policy)
|
2014-08-28 12:52:28 +07:00
|
|
|
{
|
|
|
|
struct private_data *priv = policy->driver_data;
|
|
|
|
|
2015-02-04 01:21:21 +07:00
|
|
|
cpufreq_cooling_unregister(priv->cdev);
|
2014-08-28 12:52:28 +07:00
|
|
|
dev_pm_opp_free_cpufreq_table(priv->cpu_dev, &policy->freq_table);
|
2015-09-04 15:17:24 +07:00
|
|
|
dev_pm_opp_of_cpumask_remove_table(policy->related_cpus);
|
2016-02-09 12:00:43 +07:00
|
|
|
if (priv->reg_name)
|
2016-12-01 17:58:19 +07:00
|
|
|
dev_pm_opp_put_regulators(priv->opp_table);
|
2016-02-09 12:00:43 +07:00
|
|
|
|
2014-08-28 12:52:28 +07:00
|
|
|
clk_put(policy->clk);
|
|
|
|
kfree(priv);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-11-27 07:37:52 +07:00
|
|
|
static void cpufreq_ready(struct cpufreq_policy *policy)
|
|
|
|
{
|
|
|
|
struct private_data *priv = policy->driver_data;
|
|
|
|
struct device_node *np = of_node_get(priv->cpu_dev->of_node);
|
|
|
|
|
|
|
|
if (WARN_ON(!np))
|
|
|
|
return;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* For now, just loading the cooling device;
|
|
|
|
* thermal DT code takes care of matching them.
|
|
|
|
*/
|
|
|
|
if (of_find_property(np, "#cooling-cells", NULL)) {
|
2015-11-17 19:06:22 +07:00
|
|
|
u32 power_coefficient = 0;
|
|
|
|
|
|
|
|
of_property_read_u32(np, "dynamic-power-coefficient",
|
|
|
|
&power_coefficient);
|
|
|
|
|
|
|
|
priv->cdev = of_cpufreq_power_cooling_register(np,
|
2017-04-25 17:27:14 +07:00
|
|
|
policy, power_coefficient, NULL);
|
2014-11-27 07:37:52 +07:00
|
|
|
if (IS_ERR(priv->cdev)) {
|
|
|
|
dev_err(priv->cpu_dev,
|
|
|
|
"running cpufreq without cooling device: %ld\n",
|
|
|
|
PTR_ERR(priv->cdev));
|
|
|
|
|
|
|
|
priv->cdev = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
of_node_put(np);
|
|
|
|
}
|
|
|
|
|
2014-09-09 21:28:03 +07:00
|
|
|
static struct cpufreq_driver dt_cpufreq_driver = {
|
2014-08-28 12:52:28 +07:00
|
|
|
.flags = CPUFREQ_STICKY | CPUFREQ_NEED_INITIAL_FREQ_CHECK,
|
|
|
|
.verify = cpufreq_generic_frequency_table_verify,
|
2014-09-09 21:28:03 +07:00
|
|
|
.target_index = set_target,
|
2014-08-28 12:52:28 +07:00
|
|
|
.get = cpufreq_generic_get,
|
2014-09-09 21:28:03 +07:00
|
|
|
.init = cpufreq_init,
|
|
|
|
.exit = cpufreq_exit,
|
2014-11-27 07:37:52 +07:00
|
|
|
.ready = cpufreq_ready,
|
2014-09-09 21:28:03 +07:00
|
|
|
.name = "cpufreq-dt",
|
2015-08-07 18:59:16 +07:00
|
|
|
.attr = cpufreq_dt_attr,
|
2015-09-08 23:41:03 +07:00
|
|
|
.suspend = cpufreq_generic_suspend,
|
2014-08-28 12:52:28 +07:00
|
|
|
};
|
|
|
|
|
2014-09-09 21:28:03 +07:00
|
|
|
static int dt_cpufreq_probe(struct platform_device *pdev)
|
2014-08-28 12:52:28 +07:00
|
|
|
{
|
2016-09-09 18:18:08 +07:00
|
|
|
struct cpufreq_dt_platform_data *data = dev_get_platdata(&pdev->dev);
|
2014-08-28 12:52:28 +07: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 12:00:48 +07:00
|
|
|
ret = resources_available();
|
2014-08-28 12:52:28 +07:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
2016-09-09 18:18:08 +07:00
|
|
|
if (data && data->have_governor_per_policy)
|
|
|
|
dt_cpufreq_driver.flags |= CPUFREQ_HAVE_GOVERNOR_PER_POLICY;
|
|
|
|
|
2014-09-09 21:28:03 +07:00
|
|
|
ret = cpufreq_register_driver(&dt_cpufreq_driver);
|
2014-08-28 12:52:28 +07:00
|
|
|
if (ret)
|
2016-02-09 12:00:48 +07:00
|
|
|
dev_err(&pdev->dev, "failed register driver: %d\n", ret);
|
2014-08-28 12:52:28 +07:00
|
|
|
|
2012-09-06 14:09:11 +07:00
|
|
|
return ret;
|
|
|
|
}
|
2013-01-30 21:27:49 +07:00
|
|
|
|
2014-09-09 21:28:03 +07:00
|
|
|
static int dt_cpufreq_remove(struct platform_device *pdev)
|
2013-01-30 21:27:49 +07:00
|
|
|
{
|
2014-09-09 21:28:03 +07:00
|
|
|
cpufreq_unregister_driver(&dt_cpufreq_driver);
|
2013-01-30 21:27:49 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-09-09 21:28:03 +07:00
|
|
|
static struct platform_driver dt_cpufreq_platdrv = {
|
2013-01-30 21:27:49 +07:00
|
|
|
.driver = {
|
2014-09-09 21:28:03 +07:00
|
|
|
.name = "cpufreq-dt",
|
2013-01-30 21:27:49 +07:00
|
|
|
},
|
2014-09-09 21:28:03 +07:00
|
|
|
.probe = dt_cpufreq_probe,
|
|
|
|
.remove = dt_cpufreq_remove,
|
2013-01-30 21:27:49 +07:00
|
|
|
};
|
2014-09-09 21:28:03 +07:00
|
|
|
module_platform_driver(dt_cpufreq_platdrv);
|
2012-09-06 14:09:11 +07:00
|
|
|
|
2015-05-09 02:57:30 +07:00
|
|
|
MODULE_ALIAS("platform:cpufreq-dt");
|
2014-08-28 12:52:24 +07:00
|
|
|
MODULE_AUTHOR("Viresh Kumar <viresh.kumar@linaro.org>");
|
2012-09-06 14:09:11 +07:00
|
|
|
MODULE_AUTHOR("Shawn Guo <shawn.guo@linaro.org>");
|
2014-09-09 21:28:03 +07:00
|
|
|
MODULE_DESCRIPTION("Generic cpufreq driver");
|
2012-09-06 14:09:11 +07:00
|
|
|
MODULE_LICENSE("GPL");
|