// SPDX-License-Identifier: GPL-2.0-only/* * CPPC (Collaborative Processor Performance Control) driver for * interfacing with the CPUfreq layer and governors. See * cppc_acpi.c for CPPC specific methods. * * (C) Copyright 2014, 2015 Linaro Ltd. * Author: Ashwin Chaugule <ashwin.chaugule@linaro.org> */ #define pr_fmt(fmt)	"CPPC Cpufreq:"	fmt #include <linux/arch_topology.h>#include <linux/kernel.h>#include <linux/module.h>#include <linux/delay.h>#include <linux/cpu.h>#include <linux/cpufreq.h>#include <linux/irq_work.h>#include <linux/kthread.h>#include <linux/time.h>#include <linux/vmalloc.h>#include <uapi/linux/sched/types.h> #include <linux/unaligned.h> #include <acpi/cppc_acpi.h> static struct cpufreq_driver cppc_cpufreq_driver; #ifdef CONFIG_ACPI_CPPC_CPUFREQ_FIEstatic enum {	FIE_UNSET = -1,	FIE_ENABLED,	FIE_DISABLED} fie_disabled = FIE_UNSET; module_param(fie_disabled, int, 0444);MODULE_PARM_DESC(fie_disabled, "Disable Frequency Invariance Engine (FIE)"); /* Frequency invariance support */struct cppc_freq_invariance {	int cpu;	struct irq_work irq_work;	struct kthread_work work;	struct cppc_perf_fb_ctrs prev_perf_fb_ctrs;	struct cppc_cpudata *cpu_data;}; static DEFINE_PER_CPU(struct cppc_freq_invariance, cppc_freq_inv);static struct kthread_worker *kworker_fie; static int cppc_perf_from_fbctrs(u64 reference_perf,				 struct cppc_perf_fb_ctrs *fb_ctrs_t0,				 struct cppc_perf_fb_ctrs *fb_ctrs_t1); /** * __cppc_scale_freq_tick - CPPC arch_freq_scale updater for frequency invariance * @cppc_fi: per-cpu CPPC FIE data. * * The CPPC driver registers itself with the topology core to provide its own * implementation (cppc_scale_freq_tick()) of topology_scale_freq_tick() which * gets called by the scheduler on every tick. * * Note that the arch specific counters have higher priority than CPPC counters, * if available, though the CPPC driver doesn't need to have any special * handling for that. */static void __cppc_scale_freq_tick(struct cppc_freq_invariance *cppc_fi){	struct cppc_perf_fb_ctrs fb_ctrs = {0};	struct cppc_cpudata *cpu_data;	unsigned long local_freq_scale;	u64 perf, ref_perf; 	cpu_data = cppc_fi->cpu_data; 	if (cppc_get_perf_ctrs(cppc_fi->cpu, &fb_ctrs)) {		pr_warn("%s: failed to read perf counters\n", __func__);		return;	} 	ref_perf = cpu_data->perf_caps.reference_perf;	perf = cppc_perf_from_fbctrs(ref_perf,				     &cppc_fi->prev_perf_fb_ctrs, &fb_ctrs);	if (!perf)		return; 	cppc_fi->prev_perf_fb_ctrs = fb_ctrs; 	perf <<= SCHED_CAPACITY_SHIFT;	local_freq_scale = div64_u64(perf, cpu_data->perf_caps.highest_perf); 	/* This can happen due to counter's overflow */	if (unlikely(local_freq_scale > 1024))		local_freq_scale = 1024; 	per_cpu(arch_freq_scale, cppc_fi->cpu) = local_freq_scale;} static void cppc_scale_freq_tick(void){	__cppc_scale_freq_tick(&per_cpu(cppc_freq_inv, smp_processor_id()));} static struct scale_freq_data cppc_sftd = {	.source = SCALE_FREQ_SOURCE_CPPC,	.set_freq_scale = cppc_scale_freq_tick,}; static void cppc_scale_freq_workfn(struct kthread_work *work){	struct cppc_freq_invariance *cppc_fi; 	cppc_fi = container_of(work, struct cppc_freq_invariance, work);	__cppc_scale_freq_tick(cppc_fi);} static void cppc_irq_work(struct irq_work *irq_work){	struct cppc_freq_invariance *cppc_fi; 	cppc_fi = container_of(irq_work, struct cppc_freq_invariance, irq_work);	kthread_queue_work(kworker_fie, &cppc_fi->work);} /* * Reading perf counters may sleep if the CPC regs are in PCC.  Thus, we * schedule an irq work in scale_freq_tick (since we reach here from hard-irq * context), which then schedules a normal work item cppc_scale_freq_workfn() * that updates the per_cpu arch_freq_scale variable based on the counter * updates since the last tick. */static void cppc_scale_freq_tick_pcc(void){	struct cppc_freq_invariance *cppc_fi = &per_cpu(cppc_freq_inv, smp_processor_id()); 	/*	 * cppc_get_perf_ctrs() can potentially sleep, call that from the right	 * context.	 */	irq_work_queue(&cppc_fi->irq_work);} static struct scale_freq_data cppc_sftd_pcc = {	.source = SCALE_FREQ_SOURCE_CPPC,	.set_freq_scale = cppc_scale_freq_tick_pcc,}; static void cppc_cpufreq_cpu_fie_init(struct cpufreq_policy *policy){	struct scale_freq_data *sftd = &cppc_sftd;	struct cppc_freq_invariance *cppc_fi;	int cpu, ret; 	if (fie_disabled)		return; 	for_each_cpu(cpu, policy->cpus) {		cppc_fi = &per_cpu(cppc_freq_inv, cpu);		cppc_fi->cpu = cpu;		cppc_fi->cpu_data = policy->driver_data;		if (cppc_perf_ctrs_in_pcc_cpu(cpu)) {			kthread_init_work(&cppc_fi->work, cppc_scale_freq_workfn);			init_irq_work(&cppc_fi->irq_work, cppc_irq_work);			sftd = &cppc_sftd_pcc;		} 		ret = cppc_get_perf_ctrs(cpu, &cppc_fi->prev_perf_fb_ctrs); 		/*		 * Don't abort as the CPU was offline while the driver was		 * getting registered.		 */		if (ret && cpu_online(cpu)) {			pr_debug("%s: failed to read perf counters for cpu:%d: %d\n",				__func__, cpu, ret);			return;		}	} 	/* Register for freq-invariance */	topology_set_scale_freq_source(sftd, policy->cpus);} /* * We free all the resources on policy's removal and not on CPU removal as the * irq-work are per-cpu and the hotplug core takes care of flushing the pending * irq-works (hint: smpcfd_dying_cpu()) on CPU hotplug. Even if the kthread-work * fires on another CPU after the concerned CPU is removed, it won't harm. * * We just need to make sure to remove them all on policy->exit(). */static void cppc_cpufreq_cpu_fie_exit(struct cpufreq_policy *policy){	struct cppc_freq_invariance *cppc_fi;	int cpu; 	if (fie_disabled)		return; 	/* policy->cpus will be empty here, use related_cpus instead */	topology_clear_scale_freq_source(SCALE_FREQ_SOURCE_CPPC, policy->related_cpus); 	for_each_cpu(cpu, policy->related_cpus) {		if (!cppc_perf_ctrs_in_pcc_cpu(cpu))			continue;		cppc_fi = &per_cpu(cppc_freq_inv, cpu);		irq_work_sync(&cppc_fi->irq_work);		kthread_cancel_work_sync(&cppc_fi->work);	}} static void cppc_fie_kworker_init(void){	struct sched_attr attr = {		.size		= sizeof(struct sched_attr),		.sched_policy	= SCHED_DEADLINE,		.sched_nice	= 0,		.sched_priority	= 0,		/*		 * Fake (unused) bandwidth; workaround to "fix"		 * priority inheritance.		 */		.sched_runtime	= NSEC_PER_MSEC,		.sched_deadline = 10 * NSEC_PER_MSEC,		.sched_period	= 10 * NSEC_PER_MSEC,	};	int ret; 	kworker_fie = kthread_run_worker(0, "cppc_fie");	if (IS_ERR(kworker_fie)) {		pr_warn("%s: failed to create kworker_fie: %ld\n", __func__,			PTR_ERR(kworker_fie));		fie_disabled = FIE_DISABLED;		kworker_fie = NULL;		return;	} 	ret = sched_setattr_nocheck(kworker_fie->task, &attr);	if (ret) {		pr_warn("%s: failed to set SCHED_DEADLINE: %d\n", __func__,			ret);		kthread_destroy_worker(kworker_fie);		fie_disabled = FIE_DISABLED;		kworker_fie = NULL;	}} static void __init cppc_freq_invariance_init(void){	bool perf_ctrs_in_pcc = cppc_perf_ctrs_in_pcc(); 	if (fie_disabled == FIE_UNSET) {		if (perf_ctrs_in_pcc) {			pr_info("FIE not enabled on systems with registers in PCC\n");			fie_disabled = FIE_DISABLED;		} else {			fie_disabled = FIE_ENABLED;		}	} 	if (fie_disabled || !perf_ctrs_in_pcc)		return; 	cppc_fie_kworker_init();} static void cppc_freq_invariance_exit(void){	if (kworker_fie)		kthread_destroy_worker(kworker_fie);} #elsestatic inline void cppc_cpufreq_cpu_fie_init(struct cpufreq_policy *policy){} static inline void cppc_cpufreq_cpu_fie_exit(struct cpufreq_policy *policy){} static inline void cppc_freq_invariance_init(void){} static inline void cppc_freq_invariance_exit(void){}#endif /* CONFIG_ACPI_CPPC_CPUFREQ_FIE */ static void cppc_cpufreq_get_perf_limits(struct cppc_cpudata *cpu_data,					 struct cpufreq_policy *policy,					 u32 *min_perf, u32 *max_perf){	struct cppc_perf_caps *caps = &cpu_data->perf_caps;	unsigned int min_freq, max_freq;	u32 min, max; 	min_freq = READ_ONCE(policy->min);	max_freq = READ_ONCE(policy->max);	if (unlikely(min_freq > max_freq))		min_freq = max_freq; 	min = cppc_khz_to_perf(caps, min_freq);	max = cppc_khz_to_perf(caps, max_freq); 	*min_perf = clamp_t(u32, min, caps->lowest_perf, caps->highest_perf);	*max_perf = clamp_t(u32, max, caps->lowest_perf, caps->highest_perf);} static void cppc_cpufreq_update_perf_limits(struct cppc_cpudata *cpu_data,					    struct cpufreq_policy *policy){	cppc_cpufreq_get_perf_limits(cpu_data, policy,				     &cpu_data->perf_ctrls.min_perf,				     &cpu_data->perf_ctrls.max_perf);} static int cppc_cpufreq_set_target(struct cpufreq_policy *policy,				   unsigned int target_freq,				   unsigned int relation){	struct cppc_cpudata *cpu_data = policy->driver_data;	unsigned int cpu = policy->cpu;	struct cpufreq_freqs freqs;	int ret = 0; 	cpu_data->perf_ctrls.desired_perf =			cppc_khz_to_perf(&cpu_data->perf_caps, target_freq);	cppc_cpufreq_update_perf_limits(cpu_data, policy); 	freqs.old = policy->cur;	freqs.new = target_freq; 	cpufreq_freq_transition_begin(policy, &freqs);	ret = cppc_set_perf(cpu, &cpu_data->perf_ctrls);	cpufreq_freq_transition_end(policy, &freqs, ret != 0); 	if (ret)		pr_debug("Failed to set target on CPU:%d. ret:%d\n",			 cpu, ret); 	return ret;} static unsigned int cppc_cpufreq_fast_switch(struct cpufreq_policy *policy,					      unsigned int target_freq){	struct cppc_cpudata *cpu_data = policy->driver_data;	unsigned int cpu = policy->cpu;	u32 desired_perf;	int ret; 	desired_perf = cppc_khz_to_perf(&cpu_data->perf_caps, target_freq);	cpu_data->perf_ctrls.desired_perf = desired_perf;	cppc_cpufreq_update_perf_limits(cpu_data, policy); 	ret = cppc_set_perf(cpu, &cpu_data->perf_ctrls);	if (ret) {		pr_debug("Failed to set target on CPU:%d. ret:%d\n",			 cpu, ret);		return 0;	} 	return target_freq;} static int cppc_verify_policy(struct cpufreq_policy_data *policy){	cpufreq_verify_within_cpu_limits(policy);	return 0;} static unsigned int __cppc_cpufreq_get_transition_delay_us(unsigned int cpu){	int transition_latency_ns = cppc_get_transition_latency(cpu); 	if (transition_latency_ns < 0)		return CPUFREQ_DEFAULT_TRANSITION_LATENCY_NS / NSEC_PER_USEC; 	return transition_latency_ns / NSEC_PER_USEC;} /* * The PCC subspace describes the rate at which platform can accept commands * on the shared PCC channel (including READs which do not count towards freq * transition requests), so ideally we need to use the PCC values as a fallback * if we don't have a platform specific transition_delay_us */#ifdef CONFIG_ARM64#include <asm/cputype.h> static unsigned int cppc_cpufreq_get_transition_delay_us(unsigned int cpu){	unsigned long implementor = read_cpuid_implementor();	unsigned long part_num = read_cpuid_part_number(); 	switch (implementor) {	case ARM_CPU_IMP_QCOM:		switch (part_num) {		case QCOM_CPU_PART_FALKOR_V1:		case QCOM_CPU_PART_FALKOR:			return 10000;		}	}	return __cppc_cpufreq_get_transition_delay_us(cpu);}#elsestatic unsigned int cppc_cpufreq_get_transition_delay_us(unsigned int cpu){	return __cppc_cpufreq_get_transition_delay_us(cpu);}#endif #if defined(CONFIG_ARM64) && defined(CONFIG_ENERGY_MODEL) static DEFINE_PER_CPU(unsigned int, efficiency_class); /* Create an artificial performance state every CPPC_EM_CAP_STEP capacity unit. */#define CPPC_EM_CAP_STEP	(20)/* Increase the cost value by CPPC_EM_COST_STEP every performance state. */#define CPPC_EM_COST_STEP	(1)/* Add a cost gap correspnding to the energy of 4 CPUs. */#define CPPC_EM_COST_GAP	(4 * SCHED_CAPACITY_SCALE * CPPC_EM_COST_STEP \				/ CPPC_EM_CAP_STEP) static unsigned int get_perf_level_count(struct cpufreq_policy *policy){	struct cppc_perf_caps *perf_caps;	unsigned int min_cap, max_cap;	struct cppc_cpudata *cpu_data;	int cpu = policy->cpu; 	cpu_data = policy->driver_data;	perf_caps = &cpu_data->perf_caps;	max_cap = arch_scale_cpu_capacity(cpu);	min_cap = div_u64((u64)max_cap * perf_caps->lowest_perf,			  perf_caps->highest_perf);	if ((min_cap == 0) || (max_cap < min_cap))		return 0;	return 1 + max_cap / CPPC_EM_CAP_STEP - min_cap / CPPC_EM_CAP_STEP;} /* * The cost is defined as: *   cost = power * max_frequency / frequency */static inline unsigned long compute_cost(int cpu, int step){	return CPPC_EM_COST_GAP * per_cpu(efficiency_class, cpu) +			step * CPPC_EM_COST_STEP;} static int cppc_get_cpu_power(struct device *cpu_dev,		unsigned long *power, unsigned long *KHz){	unsigned long perf_step, perf_prev, perf, perf_check;	unsigned int min_step, max_step, step, step_check;	unsigned long prev_freq = *KHz;	unsigned int min_cap, max_cap;	struct cpufreq_policy *policy; 	struct cppc_perf_caps *perf_caps;	struct cppc_cpudata *cpu_data; 	policy = cpufreq_cpu_get_raw(cpu_dev->id);	if (!policy)		return -EINVAL; 	cpu_data = policy->driver_data;	perf_caps = &cpu_data->perf_caps;	max_cap = arch_scale_cpu_capacity(cpu_dev->id);	min_cap = div_u64((u64)max_cap * perf_caps->lowest_perf,			  perf_caps->highest_perf);	perf_step = div_u64((u64)CPPC_EM_CAP_STEP * perf_caps->highest_perf,			    max_cap);	min_step = min_cap / CPPC_EM_CAP_STEP;	max_step = max_cap / CPPC_EM_CAP_STEP; 	perf_prev = cppc_khz_to_perf(perf_caps, *KHz);	step = perf_prev / perf_step; 	if (step > max_step)		return -EINVAL; 	if (min_step == max_step) {		step = max_step;		perf = perf_caps->highest_perf;	} else if (step < min_step) {		step = min_step;		perf = perf_caps->lowest_perf;	} else {		step++;		if (step == max_step)			perf = perf_caps->highest_perf;		else			perf = step * perf_step;	}

Lines 1–500 of 1090. Load more