!13327 cpufreq: Add SEEP governor for hardware-managed P-states (b71af6f0) · Commits · EulixOS / Software / Kernel

Documentation/ABI/testing/sysfs-devices-system-cpu

+38 −0

Original line number	Diff line number	Diff line
		@@ -266,6 +266,44 @@ Description: Discover CPUs in the same CPU frequency coordination domain

		This file is only present if the acpi-cpufreq driver is in use.

		What: /sys/devices/system/cpu/cpuX/cpufreq/auto_act_window
		Date: October 2024
		Contact: linux-pm@vger.kernel.org
		Description: Autonomous activity window

		This file indicates a moving utilization sensitivity window to
		the platform's autonomous selection policy.

		Read/write an integer represents autonomous activity window (in
		microseconds) from/to this file. The max value to write is
		1270000000 but the max significand is 127. This means that if 128
		is written to this file, 127 will be stored. If the value is
		greater than 130, only the first two digits will be saved as
		significand.

		Writing a zero value to this file enable the platform to
		determine an appropriate Activity Window depending on the workload.

		Writing to this file only has meaning when Autonomous Selection is
		enabled.

		This file only presents if the cppc-cpufreq driver is in use.

		What: /sys/devices/system/cpu/cpuX/cpufreq/energy_perf
		Date: October 2024
		Contact: linux-pm@vger.kernel.org
		Description: Energy performance preference

		Read/write an 8-bit integer from/to this file. This file
		represents a range of values from 0 (performance preference) to
		0xFF (energy efficiency preference) that influences the rate of
		performance increase/decrease and the result of the hardware's
		energy efficiency and performance optimization policies.

		Writing to this file only has meaning when Autonomous Selection is
		enabled.

		This file only presents if the cppc-cpufreq driver is in use.

		What: /sys/devices/system/cpu/cpu*/cache/index3/cache_disable_{0,1}
		Date: August 2008

Documentation/admin-guide/pm/cpufreq.rst

+42 −0

Original line number	Diff line number	Diff line
		@@ -590,6 +590,48 @@ This governor exposes the following tunables:
		It effectively causes the frequency to go down ``sampling_down_factor``
		times slower than it ramps up.

		``seep``
		------------

		This governor is specifically designed for platforms with hardware-managed P-states
		through CPPC (Collaborative Processor Performance Control). Unlike other governors
		that implement their own frequency scaling algorithms, the ``seep`` governor
		delegates the P-state selection to the hardware/firmware by enabling CPPC
		autonomous mode.

		The governor requires the ``cppc_cpufreq`` driver and the platform must support
		three key CPPC capabilities:
		* Autonomous selection (auto_sel)
		* Autonomous activity window (auto_act_window)
		* Energy-Performance Preference (EPP)

		When this governor is attached to a policy, it enables the hardware autonomous
		mode, allowing the processor's firmware to directly manage frequency scaling based
		on workload characteristics. The actual P-state selection algorithms are
		implemented in firmware/hardware rather than in the operating system.

		This governor exposes the following tunables (per-policy):

		``auto_act_window``
		The time window (in microseconds) used by the hardware/firmware to observe
		and evaluate workload characteristics before making P-state decisions.
		A smaller window makes the algorithm more responsive but potentially less
		stable, while a larger window provides more stable but less responsive
		frequency scaling.

		``energy_perf``
		A value between 0 and 255 that biases the hardware's frequency scaling
		decisions between performance and energy efficiency. Lower values (closer
		to 0) favor performance at the expense of power consumption, while higher
		values (closer to 255) favor energy efficiency but may impact performance.

		The ``seep`` governor is particularly suitable for platforms where the hardware
		has more accurate and fine-grained information about the system's power and
		thermal constraints than the operating system. It can potentially provide better
		energy efficiency than software-based governors while maintaining good
		performance, as the hardware can make faster and more informed P-state
		decisions.


		Frequency Boost Support
		=======================

arch/arm64/configs/openeuler_defconfig

+1 −0

Original line number	Diff line number	Diff line
		@@ -658,6 +658,7 @@ CONFIG_CPU_FREQ_GOV_USERSPACE=y
		CONFIG_CPU_FREQ_GOV_ONDEMAND=y
		CONFIG_CPU_FREQ_GOV_CONSERVATIVE=y
		CONFIG_CPU_FREQ_GOV_SCHEDUTIL=y
		CONFIG_CPU_FREQ_GOV_SEEP=m

		#
		# CPU frequency scaling drivers

drivers/acpi/cppc_acpi.c

+150 −0

Original line number	Diff line number	Diff line
		@@ -1215,6 +1215,100 @@ static int cpc_write(int cpu, struct cpc_register_resource *reg_res, u64 val)
		return ret_val;
		}

		static int cppc_get_reg(int cpunum, enum cppc_regs reg_idx, u64 *val)
		{
		struct cpc_desc *cpc_desc = per_cpu(cpc_desc_ptr, cpunum);
		struct cppc_pcc_data *pcc_ss_data = NULL;
		struct cpc_register_resource *reg;
		int pcc_ss_id;
		int ret = 0;

		if (!cpc_desc) {
		pr_debug("No CPC descriptor for CPU:%d\n", cpunum);
		return -ENODEV;
		}

		reg = &cpc_desc->cpc_regs[reg_idx];

		if (!CPC_SUPPORTED(reg)) {
		pr_debug("CPC register is not supported\n");
		return -EOPNOTSUPP;
		}

		if (CPC_IN_PCC(reg)) {
		pcc_ss_id = per_cpu(cpu_pcc_subspace_idx, cpunum);

		if (pcc_ss_id < 0)
		return -ENODEV;

		pcc_ss_data = pcc_data[pcc_ss_id];
		down_write(&pcc_ss_data->pcc_lock);

		if (send_pcc_cmd(pcc_ss_id, CMD_READ) >= 0)
		cpc_read(cpunum, reg, val);
		else
		ret = -EIO;

		up_write(&pcc_ss_data->pcc_lock);

		return ret;
		}

		cpc_read(cpunum, reg, val);

		return 0;
		}

		static int cppc_set_reg(int cpu, enum cppc_regs reg_idx, u64 val)
		{
		struct cpc_desc *cpc_desc = per_cpu(cpc_desc_ptr, cpu);
		struct cppc_pcc_data *pcc_ss_data = NULL;
		struct cpc_register_resource *reg;
		int pcc_ss_id;
		int ret;

		if (!cpc_desc) {
		pr_debug("No CPC descriptor for CPU:%d\n", cpu);
		return -ENODEV;
		}

		reg = &cpc_desc->cpc_regs[reg_idx];

		if (!CPC_SUPPORTED(reg)) {
		pr_debug("CPC register is not supported\n");
		return -EOPNOTSUPP;
		}

		if (CPC_IN_PCC(reg)) {
		pcc_ss_id = per_cpu(cpu_pcc_subspace_idx, cpu);

		if (pcc_ss_id < 0) {
		pr_debug("Invalid pcc_ss_id\n");
		return -ENODEV;
		}

		ret = cpc_write(cpu, reg, val);
		if (ret)
		return ret;

		pcc_ss_data = pcc_data[pcc_ss_id];

		down_write(&pcc_ss_data->pcc_lock);
		/* after writing CPC, transfer the ownership of PCC to platform */
		ret = send_pcc_cmd(pcc_ss_id, CMD_WRITE);
		up_write(&pcc_ss_data->pcc_lock);
		return ret;
		}

		return cpc_write(cpu, reg, val);
		}

		int cppc_get_epp_perf(int cpunum, u64 *epp_perf)
		{
		return cppc_get_reg(cpunum, ENERGY_PERF, epp_perf);
		}
		EXPORT_SYMBOL_GPL(cppc_get_epp_perf);

		/**
		* cppc_get_desired_perf - Get the value of desired performance register.
		* @cpunum: CPU from which to get desired performance.
		@@ -1427,6 +1521,62 @@ int cppc_get_perf_ctrs(int cpunum, struct cppc_perf_fb_ctrs *perf_fb_ctrs)
		}
		EXPORT_SYMBOL_GPL(cppc_get_perf_ctrs);

		/**
		* cppc_set_auto_act_window - Write autonomous act window register.
		* @cpu : CPU to which to write register.
		* @enable : the desired value of autonomous act window register to be updated.
		*/
		int cppc_set_auto_act_window(int cpu, u64 auto_act_window)
		{
		return cppc_set_reg(cpu, AUTO_ACT_WINDOW, auto_act_window);
		}
		EXPORT_SYMBOL_GPL(cppc_set_auto_act_window);

		/**
		* cppc_get_auto_act_window - Read autonomous act window register.
		* @cpu : CPU to which to write register.
		* @enable : the desired value of autonomous act window register to be updated.
		*/
		int cppc_get_auto_act_window(int cpunum, u64 *auto_act_window)
		{
		return cppc_get_reg(cpunum, AUTO_ACT_WINDOW, auto_act_window);
		}
		EXPORT_SYMBOL_GPL(cppc_get_auto_act_window);

		/**
		* cppc_get_auto_sel - Read autonomous selection register.
		* @cpunum : CPU to which to write register.
		* @enable : the desired value of autonomous selection resiter to be updated.
		*/
		int cppc_get_auto_sel(int cpunum, u64 *auto_sel)
		{
		return cppc_get_reg(cpunum, AUTO_SEL_ENABLE, auto_sel);
		}
		EXPORT_SYMBOL_GPL(cppc_get_auto_sel);


		/**
		* cppc_set_auto_sel - Write autonomous selection register.
		* @cpu : CPU to which to write register.
		* @enable : the desired value of autonomous selection resiter to be updated.
		*/
		int cppc_set_auto_sel(int cpu, bool enable)
		{
		return cppc_set_reg(cpu, AUTO_SEL_ENABLE, enable);
		}
		EXPORT_SYMBOL_GPL(cppc_set_auto_sel);

		/**
		* cppc_set_epp - Write energe perf register.
		* @cpu : CPU to which to write register.
		* @enable : the desired value of energe perf register to be updated.
		*/
		int cppc_set_epp(int cpu, u64 epp_val)
		{
		return cppc_set_reg(cpu, ENERGY_PERF, epp_val);
		}
		EXPORT_SYMBOL_GPL(cppc_set_epp);

		/**
		* cppc_set_perf - Set a CPU's performance controls.
		* @cpu: CPU for which to set performance controls.

drivers/cpufreq/Kconfig

+20 −0

Original line number	Diff line number	Diff line
		@@ -203,6 +203,26 @@ config CPU_FREQ_GOV_SCHEDUTIL

		If in doubt, say N.

		config CPU_FREQ_GOV_SEEP
		tristate "'seep' cpufreq policy governor"
		depends on ACPI_CPPC_CPUFREQ \|\| ARM64
		select CPPC_CPUFREQ_SYSFS_INTERFACE
		select CPU_FREQ_GOV_COMMON
		help
		'seep' - This governor is designed for platforms with hardware-managed
		P-states through CPPC (Collaborative Processor Performance Control).
		It enables the hardware's autonomous frequency selection capability,
		allowing the processor to manage its own frequency based on workload.

		This governor requires the cppc_cpufreq driver and platform support
		for CPPC features including auto-selection, autonomous activity window,
		and energy-performance preference.

		To compile this driver as a module, choose M here: the
		module will be called cpufreq_seep.

		If in doubt, say N.

		comment "CPU frequency scaling drivers"

		config CPUFREQ_DT