[Deepin-Kernel-SIG] [linux 6.6-y] [HISI] Backport cpufreq/pcie/ext-gpu/soc_cache/power_meter/perf_iostat/sdei_watchdog/HOTPLUG_SMT/FEAT_PMUv3_TH module for Kunpeng new SOC (Part 1)

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

@@ -268,6 +268,45 @@ Description:	Discover CPUs in the same CPU frequency coordination domain
 		This file is only present if the acpi-cpufreq or the cppc-cpufreq
 		drivers are 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

@@ -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
 =======================

drivers/acpi/cppc_acpi.c

@@ -1213,6 +1213,11 @@ static int cppc_get_perf(int cpunum, enum cppc_regs reg_idx, u64 *perf)
 		return ret;
 	}
 
+	if (!CPC_SUPPORTED(reg)) {
+		pr_debug("CPC register %d is not supported\n", reg_idx);
+		return -EOPNOTSUPP;
+	}
+
 	cpc_read(cpunum, reg, perf);
 
 	return 0;
@@ -1538,6 +1543,139 @@ int cppc_set_epp_perf(int cpu, struct cppc_perf_ctrls *perf_ctrls, bool enable)
 }
 EXPORT_SYMBOL_GPL(cppc_set_epp_perf);
 
+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 (reg_idx=%u) is not supported\n", reg_idx);
+		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 (reg_idx=%u) is not supported\n", reg_idx);
+		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);
+}
+
+/**
+ * cppc_set_epp() - Write the EPP register
+ * @cpu:CPU on which to write register.
+ * @epp_val:Value to write to the EPP register.
+ */
+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_get_auto_act_window() - Read autonomous activity window register.
+ * @cpunum:CPU from which to read register.
+ * @auto_act_window:Return address.
+ */
+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_set_auto_act_window() - Write autonomous activity window register.
+ * @cpu:CPU on which to write register.
+ * @auto_act_window:Value to write to the autonomous activity window register.
+ */
+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_sel() - Read autonomous selection register.
+ * @cpunum:CPU from which to read register.
+ * @auto_act_window:Return address.
+ */
+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_get_auto_sel_caps - Read autonomous selection register.
  * @cpunum : CPU from which to read register.
@@ -1625,12 +1763,17 @@ int cppc_set_auto_sel(int cpu, bool enable)
 		/* 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);
-	} else {
-		ret = -ENOTSUPP;
-		pr_debug("_CPC in PCC is not supported\n");
+
+		return ret;
 	}
 
-	return ret;
+	if (!CPC_SUPPORTED(auto_sel_reg)) {
+		pr_debug("CPC register (reg_idx=%u) is not supported\n",
+			 AUTO_SEL_ENABLE);
+		return -EOPNOTSUPP;
+	}
+
+	return cpc_write(cpu, auto_sel_reg, enable);
 }
 EXPORT_SYMBOL_GPL(cppc_set_auto_sel);
 

drivers/cpufreq/Kconfig

@@ -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

drivers/cpufreq/Kconfig.arm

@@ -19,6 +19,17 @@ config ACPI_CPPC_CPUFREQ
 
 	  If in doubt, say N.
 
+config CPPC_CPUFREQ_SYSFS_INTERFACE
+    bool "Enable CPPC CPUFreq sysfs tuning interfaces"
+    depends on ACPI_CPPC_CPUFREQ && ARM64
+    default n
+    help
+      This enables sysfs interfaces for CPPC CPUFreq driver including
+      auto_act_window and energy_perf. These interfaces allow users
+      to tune CPPC parameters at runtime.
+
+      If unsure, say N.
+
 config ACPI_CPPC_CPUFREQ_FIE
 	bool "Frequency Invariance support for CPPC cpufreq driver"
 	depends on ACPI_CPPC_CPUFREQ && GENERIC_ARCH_TOPOLOGY

drivers/cpufreq/Makefile

@@ -11,6 +11,7 @@ obj-$(CONFIG_CPU_FREQ_GOV_POWERSAVE)	+= cpufreq_powersave.o
 obj-$(CONFIG_CPU_FREQ_GOV_USERSPACE)	+= cpufreq_userspace.o
 obj-$(CONFIG_CPU_FREQ_GOV_ONDEMAND)	+= cpufreq_ondemand.o
 obj-$(CONFIG_CPU_FREQ_GOV_CONSERVATIVE)	+= cpufreq_conservative.o
+obj-$(CONFIG_CPU_FREQ_GOV_SEEP)		+= cpufreq_seep.o
 obj-$(CONFIG_CPU_FREQ_GOV_COMMON)		+= cpufreq_governor.o
 obj-$(CONFIG_CPU_FREQ_GOV_ATTR_SET)	+= cpufreq_governor_attr_set.o
 

drivers/cpufreq/acpi-cpufreq.c

@@ -970,11 +970,6 @@ static int acpi_cpufreq_cpu_init(struct cpufreq_policy *policy)
 	if (perf->states[0].core_frequency * 1000 != freq_table[0].frequency)
 		pr_warn(FW_WARN "P-state 0 is not max freq\n");
 
-	if (acpi_cpufreq_driver.set_boost) {
-		set_boost(policy, acpi_cpufreq_driver.boost_enabled);
-		policy->boost_enabled = acpi_cpufreq_driver.boost_enabled;
-	}
-
 	return result;
 
 err_unreg: