Merge back earlier cpufreq material for 6.20 (39385cbd) · Commits · git / linux-net

MAINTAINERS

+0 −1

Original line number	Diff line number	Diff line
		@@ -19145,7 +19145,6 @@ M: Kevin Hilman <khilman@kernel.org>
		L: linux-omap@vger.kernel.org
		S: Maintained
		F: arch/arm/omap/pm
		F: drivers/cpufreq/omap-cpufreq.c

		OMAP POWERDOMAIN SOC ADAPTATION LAYER SUPPORT
		M: Paul Walmsley <paul@pwsan.com>

drivers/cpufreq/Kconfig.arm

+0 −5

Original line number	Diff line number	Diff line
		@@ -141,11 +141,6 @@ config ARM_MEDIATEK_CPUFREQ_HW
		The driver implements the cpufreq interface for this HW engine.
		Say Y if you want to support CPUFreq HW.

		config ARM_OMAP2PLUS_CPUFREQ
		bool "TI OMAP2+"
		depends on ARCH_OMAP2PLUS \|\| COMPILE_TEST
		default ARCH_OMAP2PLUS

		config ARM_QCOM_CPUFREQ_NVMEM
		tristate "Qualcomm nvmem based CPUFreq"
		depends on ARCH_QCOM \|\| COMPILE_TEST

drivers/cpufreq/Makefile

+0 −1

Original line number	Diff line number	Diff line
		@@ -69,7 +69,6 @@ obj-$(CONFIG_ARM_KIRKWOOD_CPUFREQ) += kirkwood-cpufreq.o
		obj-$(CONFIG_ARM_MEDIATEK_CPUFREQ) += mediatek-cpufreq.o
		obj-$(CONFIG_ARM_MEDIATEK_CPUFREQ_HW) += mediatek-cpufreq-hw.o
		obj-$(CONFIG_MACH_MVEBU_V7) += mvebu-cpufreq.o
		obj-$(CONFIG_ARM_OMAP2PLUS_CPUFREQ) += omap-cpufreq.o
		obj-$(CONFIG_ARM_PXA2xx_CPUFREQ) += pxa2xx-cpufreq.o
		obj-$(CONFIG_PXA3xx) += pxa3xx-cpufreq.o
		obj-$(CONFIG_ARM_QCOM_CPUFREQ_HW) += qcom-cpufreq-hw.o

drivers/cpufreq/cpufreq.c

+6 −7

Original line number	Diff line number	Diff line
		@@ -2803,7 +2803,7 @@ static int cpufreq_boost_trigger_state(int state)
		{
		struct cpufreq_policy *policy;
		unsigned long flags;
		int ret = 0;
		int ret = -EOPNOTSUPP;

		/*
		* Don't compare 'cpufreq_driver->boost_enabled' with 'state' here to
		@@ -2820,16 +2820,15 @@ static int cpufreq_boost_trigger_state(int state)
		continue;

		ret = policy_set_boost(policy, state);
		if (ret)
		goto err_reset_state;
		if (unlikely(ret))
		break;
		}

		cpus_read_unlock();

		if (likely(!ret))
		return 0;

		err_reset_state:
		cpus_read_unlock();

		write_lock_irqsave(&cpufreq_driver_lock, flags);
		cpufreq_driver->boost_enabled = !state;
		write_unlock_irqrestore(&cpufreq_driver_lock, flags);

drivers/cpufreq/omap-cpufreq.c

deleted100644 → 0

+0 −195

Original line number	Diff line number	Diff line
		// SPDX-License-Identifier: GPL-2.0-only
		/*
		* CPU frequency scaling for OMAP using OPP information
		*
		* Copyright (C) 2005 Nokia Corporation
		* Written by Tony Lindgren <tony@atomide.com>
		*
		* Based on cpu-sa1110.c, Copyright (C) 2001 Russell King
		*
		* Copyright (C) 2007-2011 Texas Instruments, Inc.
		* - OMAP3/4 support by Rajendra Nayak, Santosh Shilimkar
		*/

		#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

		#include <linux/types.h>
		#include <linux/kernel.h>
		#include <linux/sched.h>
		#include <linux/cpufreq.h>
		#include <linux/delay.h>
		#include <linux/init.h>
		#include <linux/err.h>
		#include <linux/clk.h>
		#include <linux/io.h>
		#include <linux/pm_opp.h>
		#include <linux/cpu.h>
		#include <linux/module.h>
		#include <linux/platform_device.h>
		#include <linux/regulator/consumer.h>

		/* OPP tolerance in percentage */
		#define OPP_TOLERANCE 4

		static struct cpufreq_frequency_table *freq_table;
		static atomic_t freq_table_users = ATOMIC_INIT(0);
		static struct device *mpu_dev;
		static struct regulator *mpu_reg;

		static int omap_target(struct cpufreq_policy *policy, unsigned int index)
		{
		int r, ret;
		struct dev_pm_opp *opp;
		unsigned long freq, volt = 0, volt_old = 0, tol = 0;
		unsigned int old_freq, new_freq;

		old_freq = policy->cur;
		new_freq = freq_table[index].frequency;

		freq = new_freq * 1000;
		ret = clk_round_rate(policy->clk, freq);
		if (ret < 0) {
		dev_warn(mpu_dev,
		"CPUfreq: Cannot find matching frequency for %lu\n",
		freq);
		return ret;
		}
		freq = ret;

		if (mpu_reg) {
		opp = dev_pm_opp_find_freq_ceil(mpu_dev, &freq);
		if (IS_ERR(opp)) {
		dev_err(mpu_dev, "%s: unable to find MPU OPP for %d\n",
		__func__, new_freq);
		return -EINVAL;
		}
		volt = dev_pm_opp_get_voltage(opp);
		dev_pm_opp_put(opp);
		tol = volt * OPP_TOLERANCE / 100;
		volt_old = regulator_get_voltage(mpu_reg);
		}

		dev_dbg(mpu_dev, "cpufreq-omap: %u MHz, %ld mV --> %u MHz, %ld mV\n",
		old_freq / 1000, volt_old ? volt_old / 1000 : -1,
		new_freq / 1000, volt ? volt / 1000 : -1);

		/* scaling up? scale voltage before frequency */
		if (mpu_reg && (new_freq > old_freq)) {
		r = regulator_set_voltage(mpu_reg, volt - tol, volt + tol);
		if (r < 0) {
		dev_warn(mpu_dev, "%s: unable to scale voltage up.\n",
		__func__);
		return r;
		}
		}

		ret = clk_set_rate(policy->clk, new_freq * 1000);

		/* scaling down? scale voltage after frequency */
		if (mpu_reg && (new_freq < old_freq)) {
		r = regulator_set_voltage(mpu_reg, volt - tol, volt + tol);
		if (r < 0) {
		dev_warn(mpu_dev, "%s: unable to scale voltage down.\n",
		__func__);
		clk_set_rate(policy->clk, old_freq * 1000);
		return r;
		}
		}

		return ret;
		}

		static inline void freq_table_free(void)
		{
		if (atomic_dec_and_test(&freq_table_users))
		dev_pm_opp_free_cpufreq_table(mpu_dev, &freq_table);
		}

		static int omap_cpu_init(struct cpufreq_policy *policy)
		{
		int result;

		policy->clk = clk_get(NULL, "cpufreq_ck");
		if (IS_ERR(policy->clk))
		return PTR_ERR(policy->clk);

		if (!freq_table) {
		result = dev_pm_opp_init_cpufreq_table(mpu_dev, &freq_table);
		if (result) {
		dev_err(mpu_dev,
		"%s: cpu%d: failed creating freq table[%d]\n",
		__func__, policy->cpu, result);
		clk_put(policy->clk);
		return result;
		}
		}

		atomic_inc_return(&freq_table_users);

		/* FIXME: what's the actual transition time? */
		cpufreq_generic_init(policy, freq_table, 300 * 1000);

		return 0;
		}

		static void omap_cpu_exit(struct cpufreq_policy *policy)
		{
		freq_table_free();
		clk_put(policy->clk);
		}

		static struct cpufreq_driver omap_driver = {
		.flags = CPUFREQ_NEED_INITIAL_FREQ_CHECK,
		.verify = cpufreq_generic_frequency_table_verify,
		.target_index = omap_target,
		.get = cpufreq_generic_get,
		.init = omap_cpu_init,
		.exit = omap_cpu_exit,
		.register_em = cpufreq_register_em_with_opp,
		.name = "omap",
		};

		static int omap_cpufreq_probe(struct platform_device *pdev)
		{
		mpu_dev = get_cpu_device(0);
		if (!mpu_dev) {
		pr_warn("%s: unable to get the MPU device\n", __func__);
		return -EINVAL;
		}

		mpu_reg = regulator_get(mpu_dev, "vcc");
		if (IS_ERR(mpu_reg)) {
		pr_warn("%s: unable to get MPU regulator\n", __func__);
		mpu_reg = NULL;
		} else {
		/*
		* Ensure physical regulator is present.
		* (e.g. could be dummy regulator.)
		*/
		if (regulator_get_voltage(mpu_reg) < 0) {
		pr_warn("%s: physical regulator not present for MPU\n",
		__func__);
		regulator_put(mpu_reg);
		mpu_reg = NULL;
		}
		}

		return cpufreq_register_driver(&omap_driver);
		}

		static void omap_cpufreq_remove(struct platform_device *pdev)
		{
		cpufreq_unregister_driver(&omap_driver);
		}

		static struct platform_driver omap_cpufreq_platdrv = {
		.driver = {
		.name = "omap-cpufreq",
		},
		.probe = omap_cpufreq_probe,
		.remove = omap_cpufreq_remove,
		};
		module_platform_driver(omap_cpufreq_platdrv);

		MODULE_DESCRIPTION("cpufreq driver for OMAP SoCs");
		MODULE_LICENSE("GPL");