mirror of
https://github.com/torvalds/linux.git
synced 2024-12-14 23:25:54 +00:00
1e4f63aecb
In the process of modifying a cpufreq policy, the cpufreq core makes
a copy of it including all of the internals which is stored on the
CPU stack. Because struct cpufreq_policy is relatively large, this
may cause the size of the stack frame to exceed the 2 KB limit and
so the GCC complains when -Wframe-larger-than= is used.
In fact, it is not necessary to copy the entire policy structure
in order to modify it, however.
First, because cpufreq_set_policy() obtains the min and max policy
limits from frequency QoS now, it is not necessary to pass the limits
to it from the callers. The only things that need to be passed to it
from there are the new governor pointer or (if there is a built-in
governor in the driver) the "policy" value representing the governor
choice. They both can be passed as individual arguments, though, so
make cpufreq_set_policy() take them this way and rework its callers
accordingly. This avoids making copies of cpufreq policies in the
callers of cpufreq_set_policy().
Second, cpufreq_set_policy() still needs to pass the new policy
data to the ->verify() callback of the cpufreq driver whose task
is to sanitize the min and max policy limits. It still does not
need to make a full copy of struct cpufreq_policy for this purpose,
but it needs to pass a few items from it to the driver in case they
are needed (different drivers have different needs in that respect
and all of them have to be covered). For this reason, introduce
struct cpufreq_policy_data to hold copies of the members of
struct cpufreq_policy used by the existing ->verify() driver
callbacks and pass a pointer to a temporary structure of that
type to ->verify() (instead of passing a pointer to full struct
cpufreq_policy to it).
While at it, notice that intel_pstate and longrun don't really need
to verify the "policy" value in struct cpufreq_policy, so drop those
check from them to avoid copying "policy" into struct
cpufreq_policy_data (which allows it to be slightly smaller).
Also while at it fix up white space in a couple of places and make
cpufreq_set_policy() static (as it can be so).
Fixes: 3000ce3c52 ("cpufreq: Use per-policy frequency QoS")
Link: https://lore.kernel.org/linux-pm/CAMuHMdX6-jb1W8uC2_237m8ctCpsnGp=JCxqt8pCWVqNXHmkVg@mail.gmail.com
Reported-by: kbuild test robot <lkp@intel.com>
Reported-by: Geert Uytterhoeven <geert@linux-m68k.org>
Cc: 5.4+ <stable@vger.kernel.org> # 5.4+
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
Acked-by: Viresh Kumar <viresh.kumar@linaro.org>
188 lines
4.8 KiB
C
188 lines
4.8 KiB
C
/*
|
|
* cpufreq driver for the SuperH processors.
|
|
*
|
|
* Copyright (C) 2002 - 2012 Paul Mundt
|
|
* Copyright (C) 2002 M. R. Brown
|
|
*
|
|
* Clock framework bits from arch/avr32/mach-at32ap/cpufreq.c
|
|
*
|
|
* Copyright (C) 2004-2007 Atmel Corporation
|
|
*
|
|
* This file is subject to the terms and conditions of the GNU General Public
|
|
* License. See the file "COPYING" in the main directory of this archive
|
|
* for more details.
|
|
*/
|
|
#define pr_fmt(fmt) "cpufreq: " fmt
|
|
|
|
#include <linux/types.h>
|
|
#include <linux/cpufreq.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/module.h>
|
|
#include <linux/init.h>
|
|
#include <linux/err.h>
|
|
#include <linux/cpumask.h>
|
|
#include <linux/cpu.h>
|
|
#include <linux/smp.h>
|
|
#include <linux/sched.h> /* set_cpus_allowed() */
|
|
#include <linux/clk.h>
|
|
#include <linux/percpu.h>
|
|
#include <linux/sh_clk.h>
|
|
|
|
static DEFINE_PER_CPU(struct clk, sh_cpuclk);
|
|
|
|
struct cpufreq_target {
|
|
struct cpufreq_policy *policy;
|
|
unsigned int freq;
|
|
};
|
|
|
|
static unsigned int sh_cpufreq_get(unsigned int cpu)
|
|
{
|
|
return (clk_get_rate(&per_cpu(sh_cpuclk, cpu)) + 500) / 1000;
|
|
}
|
|
|
|
static long __sh_cpufreq_target(void *arg)
|
|
{
|
|
struct cpufreq_target *target = arg;
|
|
struct cpufreq_policy *policy = target->policy;
|
|
int cpu = policy->cpu;
|
|
struct clk *cpuclk = &per_cpu(sh_cpuclk, cpu);
|
|
struct cpufreq_freqs freqs;
|
|
struct device *dev;
|
|
long freq;
|
|
|
|
if (smp_processor_id() != cpu)
|
|
return -ENODEV;
|
|
|
|
dev = get_cpu_device(cpu);
|
|
|
|
/* Convert target_freq from kHz to Hz */
|
|
freq = clk_round_rate(cpuclk, target->freq * 1000);
|
|
|
|
if (freq < (policy->min * 1000) || freq > (policy->max * 1000))
|
|
return -EINVAL;
|
|
|
|
dev_dbg(dev, "requested frequency %u Hz\n", target->freq * 1000);
|
|
|
|
freqs.old = sh_cpufreq_get(cpu);
|
|
freqs.new = (freq + 500) / 1000;
|
|
freqs.flags = 0;
|
|
|
|
cpufreq_freq_transition_begin(target->policy, &freqs);
|
|
clk_set_rate(cpuclk, freq);
|
|
cpufreq_freq_transition_end(target->policy, &freqs, 0);
|
|
|
|
dev_dbg(dev, "set frequency %lu Hz\n", freq);
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Here we notify other drivers of the proposed change and the final change.
|
|
*/
|
|
static int sh_cpufreq_target(struct cpufreq_policy *policy,
|
|
unsigned int target_freq,
|
|
unsigned int relation)
|
|
{
|
|
struct cpufreq_target data = { .policy = policy, .freq = target_freq };
|
|
|
|
return work_on_cpu(policy->cpu, __sh_cpufreq_target, &data);
|
|
}
|
|
|
|
static int sh_cpufreq_verify(struct cpufreq_policy_data *policy)
|
|
{
|
|
struct clk *cpuclk = &per_cpu(sh_cpuclk, policy->cpu);
|
|
struct cpufreq_frequency_table *freq_table;
|
|
|
|
freq_table = cpuclk->nr_freqs ? cpuclk->freq_table : NULL;
|
|
if (freq_table)
|
|
return cpufreq_frequency_table_verify(policy, freq_table);
|
|
|
|
cpufreq_verify_within_cpu_limits(policy);
|
|
|
|
policy->min = (clk_round_rate(cpuclk, 1) + 500) / 1000;
|
|
policy->max = (clk_round_rate(cpuclk, ~0UL) + 500) / 1000;
|
|
|
|
cpufreq_verify_within_cpu_limits(policy);
|
|
return 0;
|
|
}
|
|
|
|
static int sh_cpufreq_cpu_init(struct cpufreq_policy *policy)
|
|
{
|
|
unsigned int cpu = policy->cpu;
|
|
struct clk *cpuclk = &per_cpu(sh_cpuclk, cpu);
|
|
struct cpufreq_frequency_table *freq_table;
|
|
struct device *dev;
|
|
|
|
dev = get_cpu_device(cpu);
|
|
|
|
cpuclk = clk_get(dev, "cpu_clk");
|
|
if (IS_ERR(cpuclk)) {
|
|
dev_err(dev, "couldn't get CPU clk\n");
|
|
return PTR_ERR(cpuclk);
|
|
}
|
|
|
|
freq_table = cpuclk->nr_freqs ? cpuclk->freq_table : NULL;
|
|
if (freq_table) {
|
|
policy->freq_table = freq_table;
|
|
} else {
|
|
dev_notice(dev, "no frequency table found, falling back "
|
|
"to rate rounding.\n");
|
|
|
|
policy->min = policy->cpuinfo.min_freq =
|
|
(clk_round_rate(cpuclk, 1) + 500) / 1000;
|
|
policy->max = policy->cpuinfo.max_freq =
|
|
(clk_round_rate(cpuclk, ~0UL) + 500) / 1000;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int sh_cpufreq_cpu_exit(struct cpufreq_policy *policy)
|
|
{
|
|
unsigned int cpu = policy->cpu;
|
|
struct clk *cpuclk = &per_cpu(sh_cpuclk, cpu);
|
|
|
|
clk_put(cpuclk);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void sh_cpufreq_cpu_ready(struct cpufreq_policy *policy)
|
|
{
|
|
struct device *dev = get_cpu_device(policy->cpu);
|
|
|
|
dev_info(dev, "CPU Frequencies - Minimum %u.%03u MHz, "
|
|
"Maximum %u.%03u MHz.\n",
|
|
policy->min / 1000, policy->min % 1000,
|
|
policy->max / 1000, policy->max % 1000);
|
|
}
|
|
|
|
static struct cpufreq_driver sh_cpufreq_driver = {
|
|
.name = "sh",
|
|
.flags = CPUFREQ_NO_AUTO_DYNAMIC_SWITCHING,
|
|
.get = sh_cpufreq_get,
|
|
.target = sh_cpufreq_target,
|
|
.verify = sh_cpufreq_verify,
|
|
.init = sh_cpufreq_cpu_init,
|
|
.exit = sh_cpufreq_cpu_exit,
|
|
.ready = sh_cpufreq_cpu_ready,
|
|
.attr = cpufreq_generic_attr,
|
|
};
|
|
|
|
static int __init sh_cpufreq_module_init(void)
|
|
{
|
|
pr_notice("SuperH CPU frequency driver.\n");
|
|
return cpufreq_register_driver(&sh_cpufreq_driver);
|
|
}
|
|
|
|
static void __exit sh_cpufreq_module_exit(void)
|
|
{
|
|
cpufreq_unregister_driver(&sh_cpufreq_driver);
|
|
}
|
|
|
|
module_init(sh_cpufreq_module_init);
|
|
module_exit(sh_cpufreq_module_exit);
|
|
|
|
MODULE_AUTHOR("Paul Mundt <lethal@linux-sh.org>");
|
|
MODULE_DESCRIPTION("cpufreq driver for SuperH");
|
|
MODULE_LICENSE("GPL");
|