From 4eb3c2efbf033f204567cce3827dad7f8a529ec8 Mon Sep 17 00:00:00 2001 From: Rohit Gupta Date: Wed, 29 Mar 2017 12:36:24 -0700 Subject: [PATCH] cpufreq: Add snapshot of qcom-cpufreq driver This is a snapshot of qcom-cpufreq as of msm-3.10 commit Commit acdce027751d (Merge "defconfig: arm64: Enable ONESHOT_SYNC for msm8994") Change-Id: Idb99a856330566ffad6309c48edabb220cee7917 Signed-off-by: Stephen Boyd [junjiew@codeaurora.org: resolved conflicts in Kconfig.arm and Makefile. Dropped dependency on ARCH_MSM.] Signed-off-by: Junjie Wu Signed-off-by: Rohit Gupta [skip frequencies that round to same rate] Signed-off-by: David Keitel [adapt to opensource clock framework] Signed-off-by: Santosh Mardi [Remove superfluous NULL] Signed-off-by: Pavankumar Kondeti [avilaj@codeaurora.org: Fix some merge conflicts] Signed-off-by: Jonathan Avila --- .../bindings/cpufreq/msm-cpufreq.txt | 47 ++ drivers/cpufreq/Kconfig.arm | 6 + drivers/cpufreq/Makefile | 2 +- drivers/cpufreq/qcom-cpufreq.c | 481 ++++++++++++++++++ include/linux/cpuhotplug.h | 2 + 5 files changed, 537 insertions(+), 1 deletion(-) create mode 100644 Documentation/devicetree/bindings/cpufreq/msm-cpufreq.txt create mode 100644 drivers/cpufreq/qcom-cpufreq.c diff --git a/Documentation/devicetree/bindings/cpufreq/msm-cpufreq.txt b/Documentation/devicetree/bindings/cpufreq/msm-cpufreq.txt new file mode 100644 index 000000000000..942712331c14 --- /dev/null +++ b/Documentation/devicetree/bindings/cpufreq/msm-cpufreq.txt @@ -0,0 +1,47 @@ +Qualcomm MSM CPUfreq device + +msm-cpufreq is a device that represents the list of usable CPU frequencies +and provides a device handle for the CPUfreq driver to get the CPU and cache +clocks. + +Required properties: +- compatible: Must be "qcom,msm-cpufreq" +- qcom,cpufreq-table, or qcom,cpufreq-table-: + A list of usable CPU frequencies (KHz). + Use "qcom,cpufreq-table" if all CPUs in the system + should share same list of frequencies. + Use "qcom,cpufreq-table-" to describe + different CPU freq tables for different CPUs. + The table should be listed only for the first CPU + if multiple CPUs are synchronous. + +Optional properties: +- clock-names: When DT based binding of clock is available, this + provides a list of CPU subsystem clocks. + "cpuX_clk" for every CPU that's present. + "l2_clk" when an async cache/CCI is present. + +Optional properties: +- qcom,governor-per-policy: This property denotes that governor tunables + should be associated with each cpufreq policy + group instead of being global. + +Example: + qcom,msm-cpufreq { + compatible = "qcom,msm-cpufreq"; + qcom,cpufreq-table = + < 300000 >, + < 422400 >, + < 652800 >, + < 729600 >, + < 883200 >, + < 960000 >, + < 1036800 >, + < 1190400 >, + < 1267200 >, + < 1497600 >, + < 1574400 >, + < 1728000 >, + < 1958400 >, + < 2265600 >; + }; diff --git a/drivers/cpufreq/Kconfig.arm b/drivers/cpufreq/Kconfig.arm index bdce4488ded1..2c916867190f 100644 --- a/drivers/cpufreq/Kconfig.arm +++ b/drivers/cpufreq/Kconfig.arm @@ -292,3 +292,9 @@ config ACPI_CPPC_CPUFREQ support for its operation. If in doubt, say N. + +config CPU_FREQ_MSM + bool "MSM CPUFreq support" + depends on CPU_FREQ + help + This enables the CPUFreq driver for Qualcomm Technologies, Inc. CPUs. diff --git a/drivers/cpufreq/Makefile b/drivers/cpufreq/Makefile index d0f4186d5357..a6d4bfe65dda 100644 --- a/drivers/cpufreq/Makefile +++ b/drivers/cpufreq/Makefile @@ -61,6 +61,7 @@ obj-$(CONFIG_ARM_HIGHBANK_CPUFREQ) += highbank-cpufreq.o obj-$(CONFIG_ARM_IMX6Q_CPUFREQ) += imx6q-cpufreq.o obj-$(CONFIG_ARM_KIRKWOOD_CPUFREQ) += kirkwood-cpufreq.o obj-$(CONFIG_ARM_MEDIATEK_CPUFREQ) += mediatek-cpufreq.o +obj-$(CONFIG_CPU_FREQ_MSM) += qcom-cpufreq.o obj-$(CONFIG_ARM_OMAP2PLUS_CPUFREQ) += omap-cpufreq.o obj-$(CONFIG_ARM_PXA2xx_CPUFREQ) += pxa2xx-cpufreq.o obj-$(CONFIG_PXA3xx) += pxa3xx-cpufreq.o @@ -86,7 +87,6 @@ obj-$(CONFIG_ARM_VEXPRESS_SPC_CPUFREQ) += vexpress-spc-cpufreq.o obj-$(CONFIG_ACPI_CPPC_CPUFREQ) += cppc_cpufreq.o obj-$(CONFIG_MACH_MVEBU_V7) += mvebu-cpufreq.o - ################################################################################## # PowerPC platform drivers obj-$(CONFIG_CPU_FREQ_CBE) += ppc-cbe-cpufreq.o diff --git a/drivers/cpufreq/qcom-cpufreq.c b/drivers/cpufreq/qcom-cpufreq.c new file mode 100644 index 000000000000..83300abcdbc6 --- /dev/null +++ b/drivers/cpufreq/qcom-cpufreq.c @@ -0,0 +1,481 @@ +/* drivers/cpufreq/qcom-cpufreq.c + * + * MSM architecture cpufreq driver + * + * Copyright (C) 2007 Google, Inc. + * Copyright (c) 2007-2017, The Linux Foundation. All rights reserved. + * Author: Mike A. Chan + * + * This software is licensed under the terms of the GNU General Public + * License version 2, as published by the Free Software Foundation, and + * may be copied, distributed, and modified under those terms. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static DEFINE_MUTEX(l2bw_lock); + +static struct clk *cpu_clk[NR_CPUS]; +static struct clk *l2_clk; +static DEFINE_PER_CPU(struct cpufreq_frequency_table *, freq_table); +static bool hotplug_ready; + +struct cpufreq_suspend_t { + struct mutex suspend_mutex; + int device_suspended; +}; + +static DEFINE_PER_CPU(struct cpufreq_suspend_t, suspend_data); + +static int set_cpu_freq(struct cpufreq_policy *policy, unsigned int new_freq, + unsigned int index) +{ + int ret = 0; + struct cpufreq_freqs freqs; + unsigned long rate; + + freqs.old = policy->cur; + freqs.new = new_freq; + freqs.cpu = policy->cpu; + + trace_cpu_frequency_switch_start(freqs.old, freqs.new, policy->cpu); + cpufreq_freq_transition_begin(policy, &freqs); + + rate = new_freq * 1000; + rate = clk_round_rate(cpu_clk[policy->cpu], rate); + ret = clk_set_rate(cpu_clk[policy->cpu], rate); + cpufreq_freq_transition_end(policy, &freqs, ret); + if (!ret) + trace_cpu_frequency_switch_end(policy->cpu); + + return ret; +} + +static int msm_cpufreq_target(struct cpufreq_policy *policy, + unsigned int target_freq, + unsigned int relation) +{ + int ret = -EFAULT; + int index; + struct cpufreq_frequency_table *table; + + mutex_lock(&per_cpu(suspend_data, policy->cpu).suspend_mutex); + + if (per_cpu(suspend_data, policy->cpu).device_suspended) { + pr_debug("cpufreq: cpu%d scheduling frequency change in suspend\n", + policy->cpu); + ret = -EFAULT; + goto done; + } + + table = policy->freq_table; + + pr_debug("CPU[%d] target %d relation %d (%d-%d) selected %d\n", + policy->cpu, target_freq, relation, + policy->min, policy->max, table[index].frequency); + + ret = set_cpu_freq(policy, table[index].frequency, + table[index].driver_data); +done: + mutex_unlock(&per_cpu(suspend_data, policy->cpu).suspend_mutex); + return ret; +} + +static int msm_cpufreq_verify(struct cpufreq_policy *policy) +{ + cpufreq_verify_within_limits(policy, policy->cpuinfo.min_freq, + policy->cpuinfo.max_freq); + return 0; +} + +static unsigned int msm_cpufreq_get_freq(unsigned int cpu) +{ + return clk_get_rate(cpu_clk[cpu]) / 1000; +} + +static int msm_cpufreq_init(struct cpufreq_policy *policy) +{ + int cur_freq; + int index; + int ret = 0; + struct cpufreq_frequency_table *table = + per_cpu(freq_table, policy->cpu); + int cpu; + + /* + * In some SoC, some cores are clocked by same source, and their + * frequencies can not be changed independently. Find all other + * CPUs that share same clock, and mark them as controlled by + * same policy. + */ + for_each_possible_cpu(cpu) + if (cpu_clk[cpu] == cpu_clk[policy->cpu]) + cpumask_set_cpu(cpu, policy->cpus); + + ret = cpufreq_table_validate_and_show(policy, table); + if (ret) { + pr_err("cpufreq: failed to get policy min/max\n"); + return ret; + } + + cur_freq = clk_get_rate(cpu_clk[policy->cpu])/1000; + + index = cpufreq_frequency_table_target(policy, cur_freq, + CPUFREQ_RELATION_H); + /* + * Call set_cpu_freq unconditionally so that when cpu is set to + * online, frequency limit will always be updated. + */ + ret = set_cpu_freq(policy, table[index].frequency, + table[index].driver_data); + if (ret) + return ret; + pr_debug("cpufreq: cpu%d init at %d switching to %d\n", + policy->cpu, cur_freq, table[index].frequency); + policy->cur = table[index].frequency; + + return 0; +} + +static int qcom_cpufreq_dead_cpu(unsigned int cpu) +{ + /* Fail hotplug until this driver can get CPU clocks */ + if (!hotplug_ready) + return -EINVAL; + + clk_unprepare(cpu_clk[cpu]); + clk_unprepare(l2_clk); + return 0; +} + +static int qcom_cpufreq_up_cpu(unsigned int cpu) +{ + int rc; + + /* Fail hotplug until this driver can get CPU clocks */ + if (!hotplug_ready) + return -EINVAL; + + rc = clk_prepare(l2_clk); + if (rc < 0) + return rc; + rc = clk_prepare(cpu_clk[cpu]); + if (rc < 0) + clk_unprepare(l2_clk); + return rc; +} + +static int qcom_cpufreq_dying_cpu(unsigned int cpu) +{ + /* Fail hotplug until this driver can get CPU clocks */ + if (!hotplug_ready) + return -EINVAL; + + clk_disable(cpu_clk[cpu]); + clk_disable(l2_clk); + return 0; +} + +static int qcom_cpufreq_starting_cpu(unsigned int cpu) +{ + int rc; + + /* Fail hotplug until this driver can get CPU clocks */ + if (!hotplug_ready) + return -EINVAL; + + rc = clk_enable(l2_clk); + if (rc < 0) + return rc; + rc = clk_enable(cpu_clk[cpu]); + if (rc < 0) + clk_disable(l2_clk); + return rc; +} + +static int msm_cpufreq_suspend(void) +{ + int cpu; + + for_each_possible_cpu(cpu) { + mutex_lock(&per_cpu(suspend_data, cpu).suspend_mutex); + per_cpu(suspend_data, cpu).device_suspended = 1; + mutex_unlock(&per_cpu(suspend_data, cpu).suspend_mutex); + } + + return NOTIFY_DONE; +} + +static int msm_cpufreq_resume(void) +{ + int cpu, ret; + struct cpufreq_policy policy; + + for_each_possible_cpu(cpu) { + per_cpu(suspend_data, cpu).device_suspended = 0; + } + + /* + * Freq request might be rejected during suspend, resulting + * in policy->cur violating min/max constraint. + * Correct the frequency as soon as possible. + */ + get_online_cpus(); + for_each_online_cpu(cpu) { + ret = cpufreq_get_policy(&policy, cpu); + if (ret) + continue; + if (policy.cur <= policy.max && policy.cur >= policy.min) + continue; + cpufreq_update_policy(cpu); + } + put_online_cpus(); + + return NOTIFY_DONE; +} + +static int msm_cpufreq_pm_event(struct notifier_block *this, + unsigned long event, void *ptr) +{ + switch (event) { + case PM_POST_HIBERNATION: + case PM_POST_SUSPEND: + return msm_cpufreq_resume(); + case PM_HIBERNATION_PREPARE: + case PM_SUSPEND_PREPARE: + return msm_cpufreq_suspend(); + default: + return NOTIFY_DONE; + } +} + +static struct notifier_block msm_cpufreq_pm_notifier = { + .notifier_call = msm_cpufreq_pm_event, +}; + +static struct freq_attr *msm_freq_attr[] = { + &cpufreq_freq_attr_scaling_available_freqs, + NULL, +}; + +static struct cpufreq_driver msm_cpufreq_driver = { + /* lps calculations are handled here. */ + .flags = CPUFREQ_STICKY | CPUFREQ_CONST_LOOPS | + CPUFREQ_NEED_INITIAL_FREQ_CHECK, + .init = msm_cpufreq_init, + .verify = msm_cpufreq_verify, + .target = msm_cpufreq_target, + .get = msm_cpufreq_get_freq, + .name = "msm", + .attr = msm_freq_attr, +}; + +static struct cpufreq_frequency_table *cpufreq_parse_dt(struct device *dev, + char *tbl_name, int cpu) +{ + int ret, nf, i, j; + u32 *data; + struct cpufreq_frequency_table *ftbl; + + /* Parse list of usable CPU frequencies. */ + if (!of_find_property(dev->of_node, tbl_name, &nf)) + return ERR_PTR(-EINVAL); + nf /= sizeof(*data); + + if (nf == 0) + return ERR_PTR(-EINVAL); + + data = devm_kzalloc(dev, nf * sizeof(*data), GFP_KERNEL); + if (!data) + return ERR_PTR(-ENOMEM); + + ret = of_property_read_u32_array(dev->of_node, tbl_name, data, nf); + if (ret) + return ERR_PTR(ret); + + ftbl = devm_kzalloc(dev, (nf + 1) * sizeof(*ftbl), GFP_KERNEL); + if (!ftbl) + return ERR_PTR(-ENOMEM); + + j = 0; + for (i = 0; i < nf; i++) { + unsigned long f; + + f = clk_round_rate(cpu_clk[cpu], data[i] * 1000); + if (IS_ERR_VALUE(f)) + break; + f /= 1000; + + /* + * Don't repeat frequencies if they round up to the same clock + * frequency. + * + */ + if (j > 0 && f <= ftbl[j - 1].frequency) + continue; + + ftbl[j].driver_data = j; + ftbl[j].frequency = f; + j++; + } + + ftbl[j].driver_data = j; + ftbl[j].frequency = CPUFREQ_TABLE_END; + + devm_kfree(dev, data); + + return ftbl; +} + +static int msm_cpufreq_probe(struct platform_device *pdev) +{ + struct device *dev = &pdev->dev; + char clk_name[] = "cpu??_clk"; + char tbl_name[] = "qcom,cpufreq-table-??"; + struct clk *c; + int cpu; + struct cpufreq_frequency_table *ftbl; + + l2_clk = devm_clk_get(dev, "l2_clk"); + if (IS_ERR(l2_clk)) + l2_clk = NULL; + + for_each_possible_cpu(cpu) { + snprintf(clk_name, sizeof(clk_name), "cpu%d_clk", cpu); + c = devm_clk_get(dev, clk_name); + if (cpu == 0 && IS_ERR(c)) + return PTR_ERR(c); + else if (IS_ERR(c)) + c = cpu_clk[cpu-1]; + cpu_clk[cpu] = c; + } + hotplug_ready = true; + + /* Use per-policy governor tunable for some targets */ + if (of_property_read_bool(dev->of_node, "qcom,governor-per-policy")) + msm_cpufreq_driver.flags |= CPUFREQ_HAVE_GOVERNOR_PER_POLICY; + + /* Parse commong cpufreq table for all CPUs */ + ftbl = cpufreq_parse_dt(dev, "qcom,cpufreq-table", 0); + if (!IS_ERR(ftbl)) { + for_each_possible_cpu(cpu) + per_cpu(freq_table, cpu) = ftbl; + return 0; + } + + /* + * No common table. Parse individual tables for each unique + * CPU clock. + */ + for_each_possible_cpu(cpu) { + snprintf(tbl_name, sizeof(tbl_name), + "qcom,cpufreq-table-%d", cpu); + ftbl = cpufreq_parse_dt(dev, tbl_name, cpu); + + /* CPU0 must contain freq table */ + if (cpu == 0 && IS_ERR(ftbl)) { + dev_err(dev, "Failed to parse CPU0's freq table\n"); + return PTR_ERR(ftbl); + } + if (cpu == 0) { + per_cpu(freq_table, cpu) = ftbl; + continue; + } + + if (cpu_clk[cpu] != cpu_clk[cpu - 1] && IS_ERR(ftbl)) { + dev_err(dev, "Failed to parse CPU%d's freq table\n", + cpu); + return PTR_ERR(ftbl); + } + + /* Use previous CPU's table if it shares same clock */ + if (cpu_clk[cpu] == cpu_clk[cpu - 1]) { + if (!IS_ERR(ftbl)) { + dev_warn(dev, "Conflicting tables for CPU%d\n", + cpu); + devm_kfree(dev, ftbl); + } + ftbl = per_cpu(freq_table, cpu - 1); + } + per_cpu(freq_table, cpu) = ftbl; + } + + return 0; +} + +static const struct of_device_id msm_cpufreq_match_table[] = { + { .compatible = "qcom,msm-cpufreq" }, + {} +}; + +static struct platform_driver msm_cpufreq_plat_driver = { + .probe = msm_cpufreq_probe, + .driver = { + .name = "msm-cpufreq", + .of_match_table = msm_cpufreq_match_table, + }, +}; + +static int __init msm_cpufreq_register(void) +{ + int cpu, rc; + + for_each_possible_cpu(cpu) { + mutex_init(&(per_cpu(suspend_data, cpu).suspend_mutex)); + per_cpu(suspend_data, cpu).device_suspended = 0; + } + + rc = platform_driver_register(&msm_cpufreq_plat_driver); + if (rc < 0) { + /* Unblock hotplug if msm-cpufreq probe fails */ + cpuhp_remove_state_nocalls(CPUHP_QCOM_CPUFREQ_PREPARE); + cpuhp_remove_state_nocalls(CPUHP_AP_QCOM_CPUFREQ_STARTING); + for_each_possible_cpu(cpu) + mutex_destroy(&(per_cpu(suspend_data, cpu). + suspend_mutex)); + return rc; + } + + register_pm_notifier(&msm_cpufreq_pm_notifier); + return cpufreq_register_driver(&msm_cpufreq_driver); +} + +subsys_initcall(msm_cpufreq_register); + +static int __init msm_cpufreq_early_register(void) +{ + int ret; + + ret = cpuhp_setup_state_nocalls(CPUHP_AP_QCOM_CPUFREQ_STARTING, + "AP_QCOM_CPUFREQ_STARTING", + qcom_cpufreq_starting_cpu, + qcom_cpufreq_dying_cpu); + if (ret) + return ret; + + ret = cpuhp_setup_state_nocalls(CPUHP_QCOM_CPUFREQ_PREPARE, + "QCOM_CPUFREQ_PREPARE", + qcom_cpufreq_up_cpu, + qcom_cpufreq_dead_cpu); + if (!ret) + return ret; + cpuhp_remove_state_nocalls(CPUHP_AP_QCOM_CPUFREQ_STARTING); + return ret; +} +core_initcall(msm_cpufreq_early_register); diff --git a/include/linux/cpuhotplug.h b/include/linux/cpuhotplug.h index b7127ee054de..b8f603ce2ff1 100644 --- a/include/linux/cpuhotplug.h +++ b/include/linux/cpuhotplug.h @@ -74,6 +74,7 @@ enum cpuhp_state { CPUHP_POWERPC_MMU_CTX_PREPARE, CPUHP_XEN_PREPARE, CPUHP_XEN_EVTCHN_PREPARE, + CPUHP_QCOM_CPUFREQ_PREPARE, CPUHP_ARM_SHMOBILE_SCU_PREPARE, CPUHP_SH_SH3X_PREPARE, CPUHP_NET_FLOW_PREPARE, @@ -121,6 +122,7 @@ enum cpuhp_state { CPUHP_AP_ARM_TWD_STARTING, CPUHP_AP_METAG_TIMER_STARTING, CPUHP_AP_QCOM_TIMER_STARTING, + CPUHP_AP_QCOM_CPUFREQ_STARTING, CPUHP_AP_ARMADA_TIMER_STARTING, CPUHP_AP_MARCO_TIMER_STARTING, CPUHP_AP_MIPS_GIC_TIMER_STARTING,