Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * CPPC (Collaborative Processor Performance Control) driver for
4 * interfacing with the CPUfreq layer and governors. See
5 * cppc_acpi.c for CPPC specific methods.
6 *
7 * (C) Copyright 2014, 2015 Linaro Ltd.
8 * Author: Ashwin Chaugule <ashwin.chaugule@linaro.org>
9 */
10
11#define pr_fmt(fmt) "CPPC Cpufreq:" fmt
12
13#include <linux/arch_topology.h>
14#include <linux/kernel.h>
15#include <linux/module.h>
16#include <linux/delay.h>
17#include <linux/cpu.h>
18#include <linux/cpufreq.h>
19#include <linux/irq_work.h>
20#include <linux/kthread.h>
21#include <linux/time.h>
22#include <linux/vmalloc.h>
23#include <uapi/linux/sched/types.h>
24
25#include <linux/unaligned.h>
26
27#include <acpi/cppc_acpi.h>
28
29static struct cpufreq_driver cppc_cpufreq_driver;
30
31#ifdef CONFIG_ACPI_CPPC_CPUFREQ_FIE
32static enum {
33 FIE_UNSET = -1,
34 FIE_ENABLED,
35 FIE_DISABLED
36} fie_disabled = FIE_UNSET;
37
38module_param(fie_disabled, int, 0444);
39MODULE_PARM_DESC(fie_disabled, "Disable Frequency Invariance Engine (FIE)");
40
41/* Frequency invariance support */
42struct cppc_freq_invariance {
43 int cpu;
44 struct irq_work irq_work;
45 struct kthread_work work;
46 struct cppc_perf_fb_ctrs prev_perf_fb_ctrs;
47 struct cppc_cpudata *cpu_data;
48};
49
50static DEFINE_PER_CPU(struct cppc_freq_invariance, cppc_freq_inv);
51static struct kthread_worker *kworker_fie;
52
53static int cppc_perf_from_fbctrs(struct cppc_perf_fb_ctrs *fb_ctrs_t0,
54 struct cppc_perf_fb_ctrs *fb_ctrs_t1);
55
56/**
57 * __cppc_scale_freq_tick - CPPC arch_freq_scale updater for frequency invariance
58 * @cppc_fi: per-cpu CPPC FIE data.
59 *
60 * The CPPC driver registers itself with the topology core to provide its own
61 * implementation (cppc_scale_freq_tick()) of topology_scale_freq_tick() which
62 * gets called by the scheduler on every tick.
63 *
64 * Note that the arch specific counters have higher priority than CPPC counters,
65 * if available, though the CPPC driver doesn't need to have any special
66 * handling for that.
67 */
68static void __cppc_scale_freq_tick(struct cppc_freq_invariance *cppc_fi)
69{
70 struct cppc_perf_fb_ctrs fb_ctrs = {0};
71 struct cppc_cpudata *cpu_data;
72 unsigned long local_freq_scale;
73 u64 perf;
74
75 cpu_data = cppc_fi->cpu_data;
76
77 if (cppc_get_perf_ctrs(cppc_fi->cpu, &fb_ctrs)) {
78 pr_warn("%s: failed to read perf counters\n", __func__);
79 return;
80 }
81
82 perf = cppc_perf_from_fbctrs(&cppc_fi->prev_perf_fb_ctrs, &fb_ctrs);
83 if (!perf)
84 return;
85
86 cppc_fi->prev_perf_fb_ctrs = fb_ctrs;
87
88 perf <<= SCHED_CAPACITY_SHIFT;
89 local_freq_scale = div64_u64(perf, cpu_data->perf_caps.highest_perf);
90
91 /* This can happen due to counter's overflow */
92 if (unlikely(local_freq_scale > 1024))
93 local_freq_scale = 1024;
94
95 per_cpu(arch_freq_scale, cppc_fi->cpu) = local_freq_scale;
96}
97
98static void cppc_scale_freq_tick(void)
99{
100 __cppc_scale_freq_tick(&per_cpu(cppc_freq_inv, smp_processor_id()));
101}
102
103static struct scale_freq_data cppc_sftd = {
104 .source = SCALE_FREQ_SOURCE_CPPC,
105 .set_freq_scale = cppc_scale_freq_tick,
106};
107
108static void cppc_scale_freq_workfn(struct kthread_work *work)
109{
110 struct cppc_freq_invariance *cppc_fi;
111
112 cppc_fi = container_of(work, struct cppc_freq_invariance, work);
113 __cppc_scale_freq_tick(cppc_fi);
114}
115
116static void cppc_irq_work(struct irq_work *irq_work)
117{
118 struct cppc_freq_invariance *cppc_fi;
119
120 cppc_fi = container_of(irq_work, struct cppc_freq_invariance, irq_work);
121 kthread_queue_work(kworker_fie, &cppc_fi->work);
122}
123
124/*
125 * Reading perf counters may sleep if the CPC regs are in PCC. Thus, we
126 * schedule an irq work in scale_freq_tick (since we reach here from hard-irq
127 * context), which then schedules a normal work item cppc_scale_freq_workfn()
128 * that updates the per_cpu arch_freq_scale variable based on the counter
129 * updates since the last tick.
130 */
131static void cppc_scale_freq_tick_pcc(void)
132{
133 struct cppc_freq_invariance *cppc_fi = &per_cpu(cppc_freq_inv, smp_processor_id());
134
135 /*
136 * cppc_get_perf_ctrs() can potentially sleep, call that from the right
137 * context.
138 */
139 irq_work_queue(&cppc_fi->irq_work);
140}
141
142static struct scale_freq_data cppc_sftd_pcc = {
143 .source = SCALE_FREQ_SOURCE_CPPC,
144 .set_freq_scale = cppc_scale_freq_tick_pcc,
145};
146
147static void cppc_cpufreq_cpu_fie_init(struct cpufreq_policy *policy)
148{
149 struct scale_freq_data *sftd = &cppc_sftd;
150 struct cppc_freq_invariance *cppc_fi;
151 int cpu, ret;
152
153 if (fie_disabled)
154 return;
155
156 for_each_cpu(cpu, policy->cpus) {
157 cppc_fi = &per_cpu(cppc_freq_inv, cpu);
158 cppc_fi->cpu = cpu;
159 cppc_fi->cpu_data = policy->driver_data;
160 if (cppc_perf_ctrs_in_pcc_cpu(cpu)) {
161 kthread_init_work(&cppc_fi->work, cppc_scale_freq_workfn);
162 init_irq_work(&cppc_fi->irq_work, cppc_irq_work);
163 sftd = &cppc_sftd_pcc;
164 }
165
166 ret = cppc_get_perf_ctrs(cpu, &cppc_fi->prev_perf_fb_ctrs);
167
168 /*
169 * Don't abort as the CPU was offline while the driver was
170 * getting registered.
171 */
172 if (ret && cpu_online(cpu)) {
173 pr_debug("%s: failed to read perf counters for cpu:%d: %d\n",
174 __func__, cpu, ret);
175 return;
176 }
177 }
178
179 /* Register for freq-invariance */
180 topology_set_scale_freq_source(sftd, policy->cpus);
181}
182
183/*
184 * We free all the resources on policy's removal and not on CPU removal as the
185 * irq-work are per-cpu and the hotplug core takes care of flushing the pending
186 * irq-works (hint: smpcfd_dying_cpu()) on CPU hotplug. Even if the kthread-work
187 * fires on another CPU after the concerned CPU is removed, it won't harm.
188 *
189 * We just need to make sure to remove them all on policy->exit().
190 */
191static void cppc_cpufreq_cpu_fie_exit(struct cpufreq_policy *policy)
192{
193 struct cppc_freq_invariance *cppc_fi;
194 int cpu;
195
196 if (fie_disabled)
197 return;
198
199 /* policy->cpus will be empty here, use related_cpus instead */
200 topology_clear_scale_freq_source(SCALE_FREQ_SOURCE_CPPC, policy->related_cpus);
201
202 for_each_cpu(cpu, policy->related_cpus) {
203 if (!cppc_perf_ctrs_in_pcc_cpu(cpu))
204 continue;
205 cppc_fi = &per_cpu(cppc_freq_inv, cpu);
206 irq_work_sync(&cppc_fi->irq_work);
207 kthread_cancel_work_sync(&cppc_fi->work);
208 }
209}
210
211static void cppc_fie_kworker_init(void)
212{
213 struct sched_attr attr = {
214 .size = sizeof(struct sched_attr),
215 .sched_policy = SCHED_DEADLINE,
216 .sched_nice = 0,
217 .sched_priority = 0,
218 /*
219 * Fake (unused) bandwidth; workaround to "fix"
220 * priority inheritance.
221 */
222 .sched_runtime = NSEC_PER_MSEC,
223 .sched_deadline = 10 * NSEC_PER_MSEC,
224 .sched_period = 10 * NSEC_PER_MSEC,
225 };
226 int ret;
227
228 kworker_fie = kthread_run_worker(0, "cppc_fie");
229 if (IS_ERR(kworker_fie)) {
230 pr_warn("%s: failed to create kworker_fie: %ld\n", __func__,
231 PTR_ERR(kworker_fie));
232 fie_disabled = FIE_DISABLED;
233 kworker_fie = NULL;
234 return;
235 }
236
237 ret = sched_setattr_nocheck(kworker_fie->task, &attr);
238 if (ret) {
239 pr_warn("%s: failed to set SCHED_DEADLINE: %d\n", __func__,
240 ret);
241 kthread_destroy_worker(kworker_fie);
242 fie_disabled = FIE_DISABLED;
243 kworker_fie = NULL;
244 }
245}
246
247static void __init cppc_freq_invariance_init(void)
248{
249 bool perf_ctrs_in_pcc = cppc_perf_ctrs_in_pcc();
250
251 if (fie_disabled == FIE_UNSET) {
252 if (perf_ctrs_in_pcc) {
253 pr_info("FIE not enabled on systems with registers in PCC\n");
254 fie_disabled = FIE_DISABLED;
255 } else {
256 fie_disabled = FIE_ENABLED;
257 }
258 }
259
260 if (fie_disabled || !perf_ctrs_in_pcc)
261 return;
262
263 cppc_fie_kworker_init();
264}
265
266static void cppc_freq_invariance_exit(void)
267{
268 if (kworker_fie)
269 kthread_destroy_worker(kworker_fie);
270}
271
272#else
273static inline void cppc_cpufreq_cpu_fie_init(struct cpufreq_policy *policy)
274{
275}
276
277static inline void cppc_cpufreq_cpu_fie_exit(struct cpufreq_policy *policy)
278{
279}
280
281static inline void cppc_freq_invariance_init(void)
282{
283}
284
285static inline void cppc_freq_invariance_exit(void)
286{
287}
288#endif /* CONFIG_ACPI_CPPC_CPUFREQ_FIE */
289
290static int cppc_cpufreq_set_target(struct cpufreq_policy *policy,
291 unsigned int target_freq,
292 unsigned int relation)
293{
294 struct cppc_cpudata *cpu_data = policy->driver_data;
295 unsigned int cpu = policy->cpu;
296 struct cpufreq_freqs freqs;
297 int ret = 0;
298
299 cpu_data->perf_ctrls.desired_perf =
300 cppc_khz_to_perf(&cpu_data->perf_caps, target_freq);
301 freqs.old = policy->cur;
302 freqs.new = target_freq;
303
304 cpufreq_freq_transition_begin(policy, &freqs);
305 ret = cppc_set_perf(cpu, &cpu_data->perf_ctrls);
306 cpufreq_freq_transition_end(policy, &freqs, ret != 0);
307
308 if (ret)
309 pr_debug("Failed to set target on CPU:%d. ret:%d\n",
310 cpu, ret);
311
312 return ret;
313}
314
315static unsigned int cppc_cpufreq_fast_switch(struct cpufreq_policy *policy,
316 unsigned int target_freq)
317{
318 struct cppc_cpudata *cpu_data = policy->driver_data;
319 unsigned int cpu = policy->cpu;
320 u32 desired_perf;
321 int ret;
322
323 desired_perf = cppc_khz_to_perf(&cpu_data->perf_caps, target_freq);
324 cpu_data->perf_ctrls.desired_perf = desired_perf;
325 ret = cppc_set_perf(cpu, &cpu_data->perf_ctrls);
326
327 if (ret) {
328 pr_debug("Failed to set target on CPU:%d. ret:%d\n",
329 cpu, ret);
330 return 0;
331 }
332
333 return target_freq;
334}
335
336static int cppc_verify_policy(struct cpufreq_policy_data *policy)
337{
338 cpufreq_verify_within_cpu_limits(policy);
339 return 0;
340}
341
342static unsigned int __cppc_cpufreq_get_transition_delay_us(unsigned int cpu)
343{
344 int transition_latency_ns = cppc_get_transition_latency(cpu);
345
346 if (transition_latency_ns < 0)
347 return CPUFREQ_DEFAULT_TRANSITION_LATENCY_NS / NSEC_PER_USEC;
348
349 return transition_latency_ns / NSEC_PER_USEC;
350}
351
352/*
353 * The PCC subspace describes the rate at which platform can accept commands
354 * on the shared PCC channel (including READs which do not count towards freq
355 * transition requests), so ideally we need to use the PCC values as a fallback
356 * if we don't have a platform specific transition_delay_us
357 */
358#ifdef CONFIG_ARM64
359#include <asm/cputype.h>
360
361static unsigned int cppc_cpufreq_get_transition_delay_us(unsigned int cpu)
362{
363 unsigned long implementor = read_cpuid_implementor();
364 unsigned long part_num = read_cpuid_part_number();
365
366 switch (implementor) {
367 case ARM_CPU_IMP_QCOM:
368 switch (part_num) {
369 case QCOM_CPU_PART_FALKOR_V1:
370 case QCOM_CPU_PART_FALKOR:
371 return 10000;
372 }
373 }
374 return __cppc_cpufreq_get_transition_delay_us(cpu);
375}
376#else
377static unsigned int cppc_cpufreq_get_transition_delay_us(unsigned int cpu)
378{
379 return __cppc_cpufreq_get_transition_delay_us(cpu);
380}
381#endif
382
383#if defined(CONFIG_ARM64) && defined(CONFIG_ENERGY_MODEL)
384
385static DEFINE_PER_CPU(unsigned int, efficiency_class);
386
387/* Create an artificial performance state every CPPC_EM_CAP_STEP capacity unit. */
388#define CPPC_EM_CAP_STEP (20)
389/* Increase the cost value by CPPC_EM_COST_STEP every performance state. */
390#define CPPC_EM_COST_STEP (1)
391/* Add a cost gap correspnding to the energy of 4 CPUs. */
392#define CPPC_EM_COST_GAP (4 * SCHED_CAPACITY_SCALE * CPPC_EM_COST_STEP \
393 / CPPC_EM_CAP_STEP)
394
395static unsigned int get_perf_level_count(struct cpufreq_policy *policy)
396{
397 struct cppc_perf_caps *perf_caps;
398 unsigned int min_cap, max_cap;
399 struct cppc_cpudata *cpu_data;
400 int cpu = policy->cpu;
401
402 cpu_data = policy->driver_data;
403 perf_caps = &cpu_data->perf_caps;
404 max_cap = arch_scale_cpu_capacity(cpu);
405 min_cap = div_u64((u64)max_cap * perf_caps->lowest_perf,
406 perf_caps->highest_perf);
407 if ((min_cap == 0) || (max_cap < min_cap))
408 return 0;
409 return 1 + max_cap / CPPC_EM_CAP_STEP - min_cap / CPPC_EM_CAP_STEP;
410}
411
412/*
413 * The cost is defined as:
414 * cost = power * max_frequency / frequency
415 */
416static inline unsigned long compute_cost(int cpu, int step)
417{
418 return CPPC_EM_COST_GAP * per_cpu(efficiency_class, cpu) +
419 step * CPPC_EM_COST_STEP;
420}
421
422static int cppc_get_cpu_power(struct device *cpu_dev,
423 unsigned long *power, unsigned long *KHz)
424{
425 unsigned long perf_step, perf_prev, perf, perf_check;
426 unsigned int min_step, max_step, step, step_check;
427 unsigned long prev_freq = *KHz;
428 unsigned int min_cap, max_cap;
429 struct cpufreq_policy *policy;
430
431 struct cppc_perf_caps *perf_caps;
432 struct cppc_cpudata *cpu_data;
433
434 policy = cpufreq_cpu_get_raw(cpu_dev->id);
435 if (!policy)
436 return -EINVAL;
437
438 cpu_data = policy->driver_data;
439 perf_caps = &cpu_data->perf_caps;
440 max_cap = arch_scale_cpu_capacity(cpu_dev->id);
441 min_cap = div_u64((u64)max_cap * perf_caps->lowest_perf,
442 perf_caps->highest_perf);
443 perf_step = div_u64((u64)CPPC_EM_CAP_STEP * perf_caps->highest_perf,
444 max_cap);
445 min_step = min_cap / CPPC_EM_CAP_STEP;
446 max_step = max_cap / CPPC_EM_CAP_STEP;
447
448 perf_prev = cppc_khz_to_perf(perf_caps, *KHz);
449 step = perf_prev / perf_step;
450
451 if (step > max_step)
452 return -EINVAL;
453
454 if (min_step == max_step) {
455 step = max_step;
456 perf = perf_caps->highest_perf;
457 } else if (step < min_step) {
458 step = min_step;
459 perf = perf_caps->lowest_perf;
460 } else {
461 step++;
462 if (step == max_step)
463 perf = perf_caps->highest_perf;
464 else
465 perf = step * perf_step;
466 }
467
468 *KHz = cppc_perf_to_khz(perf_caps, perf);
469 perf_check = cppc_khz_to_perf(perf_caps, *KHz);
470 step_check = perf_check / perf_step;
471
472 /*
473 * To avoid bad integer approximation, check that new frequency value
474 * increased and that the new frequency will be converted to the
475 * desired step value.
476 */
477 while ((*KHz == prev_freq) || (step_check != step)) {
478 perf++;
479 *KHz = cppc_perf_to_khz(perf_caps, perf);
480 perf_check = cppc_khz_to_perf(perf_caps, *KHz);
481 step_check = perf_check / perf_step;
482 }
483
484 /*
485 * With an artificial EM, only the cost value is used. Still the power
486 * is populated such as 0 < power < EM_MAX_POWER. This allows to add
487 * more sense to the artificial performance states.
488 */
489 *power = compute_cost(cpu_dev->id, step);
490
491 return 0;
492}
493
494static int cppc_get_cpu_cost(struct device *cpu_dev, unsigned long KHz,
495 unsigned long *cost)
496{
497 unsigned long perf_step, perf_prev;
498 struct cppc_perf_caps *perf_caps;
499 struct cpufreq_policy *policy;
500 struct cppc_cpudata *cpu_data;
501 unsigned int max_cap;
502 int step;
503
504 policy = cpufreq_cpu_get_raw(cpu_dev->id);
505 if (!policy)
506 return -EINVAL;
507
508 cpu_data = policy->driver_data;
509 perf_caps = &cpu_data->perf_caps;
510 max_cap = arch_scale_cpu_capacity(cpu_dev->id);
511
512 perf_prev = cppc_khz_to_perf(perf_caps, KHz);
513 perf_step = CPPC_EM_CAP_STEP * perf_caps->highest_perf / max_cap;
514 step = perf_prev / perf_step;
515
516 *cost = compute_cost(cpu_dev->id, step);
517
518 return 0;
519}
520
521static void cppc_cpufreq_register_em(struct cpufreq_policy *policy)
522{
523 struct cppc_cpudata *cpu_data;
524 struct em_data_callback em_cb =
525 EM_ADV_DATA_CB(cppc_get_cpu_power, cppc_get_cpu_cost);
526
527 cpu_data = policy->driver_data;
528 em_dev_register_perf_domain(get_cpu_device(policy->cpu),
529 get_perf_level_count(policy), &em_cb,
530 cpu_data->shared_cpu_map, 0);
531}
532
533static void populate_efficiency_class(void)
534{
535 struct acpi_madt_generic_interrupt *gicc;
536 DECLARE_BITMAP(used_classes, 256) = {};
537 int class, cpu, index;
538
539 for_each_possible_cpu(cpu) {
540 gicc = acpi_cpu_get_madt_gicc(cpu);
541 class = gicc->efficiency_class;
542 bitmap_set(used_classes, class, 1);
543 }
544
545 if (bitmap_weight(used_classes, 256) <= 1) {
546 pr_debug("Efficiency classes are all equal (=%d). "
547 "No EM registered", class);
548 return;
549 }
550
551 /*
552 * Squeeze efficiency class values on [0:#efficiency_class-1].
553 * Values are per spec in [0:255].
554 */
555 index = 0;
556 for_each_set_bit(class, used_classes, 256) {
557 for_each_possible_cpu(cpu) {
558 gicc = acpi_cpu_get_madt_gicc(cpu);
559 if (gicc->efficiency_class == class)
560 per_cpu(efficiency_class, cpu) = index;
561 }
562 index++;
563 }
564 cppc_cpufreq_driver.register_em = cppc_cpufreq_register_em;
565}
566
567#else
568static void populate_efficiency_class(void)
569{
570}
571#endif
572
573static struct cppc_cpudata *cppc_cpufreq_get_cpu_data(unsigned int cpu)
574{
575 struct cppc_cpudata *cpu_data;
576 int ret;
577
578 cpu_data = kzalloc_obj(struct cppc_cpudata);
579 if (!cpu_data)
580 goto out;
581
582 if (!zalloc_cpumask_var(&cpu_data->shared_cpu_map, GFP_KERNEL))
583 goto free_cpu;
584
585 ret = acpi_get_psd_map(cpu, cpu_data);
586 if (ret) {
587 pr_debug("Err parsing CPU%d PSD data: ret:%d\n", cpu, ret);
588 goto free_mask;
589 }
590
591 ret = cppc_get_perf_caps(cpu, &cpu_data->perf_caps);
592 if (ret) {
593 pr_debug("Err reading CPU%d perf caps: ret:%d\n", cpu, ret);
594 goto free_mask;
595 }
596
597 return cpu_data;
598
599free_mask:
600 free_cpumask_var(cpu_data->shared_cpu_map);
601free_cpu:
602 kfree(cpu_data);
603out:
604 return NULL;
605}
606
607static void cppc_cpufreq_put_cpu_data(struct cpufreq_policy *policy)
608{
609 struct cppc_cpudata *cpu_data = policy->driver_data;
610
611 free_cpumask_var(cpu_data->shared_cpu_map);
612 kfree(cpu_data);
613 policy->driver_data = NULL;
614}
615
616static int cppc_cpufreq_cpu_init(struct cpufreq_policy *policy)
617{
618 unsigned int cpu = policy->cpu;
619 struct cppc_cpudata *cpu_data;
620 struct cppc_perf_caps *caps;
621 int ret;
622
623 cpu_data = cppc_cpufreq_get_cpu_data(cpu);
624 if (!cpu_data) {
625 pr_err("Error in acquiring _CPC/_PSD data for CPU%d.\n", cpu);
626 return -ENODEV;
627 }
628 caps = &cpu_data->perf_caps;
629 policy->driver_data = cpu_data;
630
631 /*
632 * Set min to lowest nonlinear perf to avoid any efficiency penalty (see
633 * Section 8.4.7.1.1.5 of ACPI 6.1 spec)
634 */
635 policy->min = cppc_perf_to_khz(caps, caps->lowest_nonlinear_perf);
636 policy->max = cppc_perf_to_khz(caps, policy->boost_enabled ?
637 caps->highest_perf : caps->nominal_perf);
638
639 /*
640 * Set cpuinfo.min_freq to Lowest to make the full range of performance
641 * available if userspace wants to use any perf between lowest & lowest
642 * nonlinear perf
643 */
644 policy->cpuinfo.min_freq = cppc_perf_to_khz(caps, caps->lowest_perf);
645 policy->cpuinfo.max_freq = policy->max;
646
647 policy->transition_delay_us = cppc_cpufreq_get_transition_delay_us(cpu);
648 policy->shared_type = cpu_data->shared_type;
649
650 switch (policy->shared_type) {
651 case CPUFREQ_SHARED_TYPE_HW:
652 case CPUFREQ_SHARED_TYPE_NONE:
653 /* Nothing to be done - we'll have a policy for each CPU */
654 break;
655 case CPUFREQ_SHARED_TYPE_ANY:
656 /*
657 * All CPUs in the domain will share a policy and all cpufreq
658 * operations will use a single cppc_cpudata structure stored
659 * in policy->driver_data.
660 */
661 cpumask_copy(policy->cpus, cpu_data->shared_cpu_map);
662 break;
663 default:
664 pr_debug("Unsupported CPU co-ord type: %d\n",
665 policy->shared_type);
666 ret = -EFAULT;
667 goto out;
668 }
669
670 policy->fast_switch_possible = cppc_allow_fast_switch();
671 policy->dvfs_possible_from_any_cpu = true;
672
673 /*
674 * If 'highest_perf' is greater than 'nominal_perf', we assume CPU Boost
675 * is supported.
676 */
677 if (caps->highest_perf > caps->nominal_perf)
678 policy->boost_supported = true;
679
680 /* Set policy->cur to max now. The governors will adjust later. */
681 policy->cur = cppc_perf_to_khz(caps, caps->highest_perf);
682 cpu_data->perf_ctrls.desired_perf = caps->highest_perf;
683
684 ret = cppc_set_perf(cpu, &cpu_data->perf_ctrls);
685 if (ret) {
686 pr_debug("Err setting perf value:%d on CPU:%d. ret:%d\n",
687 caps->highest_perf, cpu, ret);
688 goto out;
689 }
690
691 cppc_cpufreq_cpu_fie_init(policy);
692 return 0;
693
694out:
695 cppc_cpufreq_put_cpu_data(policy);
696 return ret;
697}
698
699static void cppc_cpufreq_cpu_exit(struct cpufreq_policy *policy)
700{
701 struct cppc_cpudata *cpu_data = policy->driver_data;
702 struct cppc_perf_caps *caps = &cpu_data->perf_caps;
703 unsigned int cpu = policy->cpu;
704 int ret;
705
706 cppc_cpufreq_cpu_fie_exit(policy);
707
708 cpu_data->perf_ctrls.desired_perf = caps->lowest_perf;
709
710 ret = cppc_set_perf(cpu, &cpu_data->perf_ctrls);
711 if (ret)
712 pr_debug("Err setting perf value:%d on CPU:%d. ret:%d\n",
713 caps->lowest_perf, cpu, ret);
714
715 cppc_cpufreq_put_cpu_data(policy);
716}
717
718static inline u64 get_delta(u64 t1, u64 t0)
719{
720 if (t1 > t0 || t0 > ~(u32)0)
721 return t1 - t0;
722
723 return (u32)t1 - (u32)t0;
724}
725
726static int cppc_perf_from_fbctrs(struct cppc_perf_fb_ctrs *fb_ctrs_t0,
727 struct cppc_perf_fb_ctrs *fb_ctrs_t1)
728{
729 u64 delta_reference, delta_delivered;
730 u64 reference_perf;
731
732 reference_perf = fb_ctrs_t0->reference_perf;
733
734 delta_reference = get_delta(fb_ctrs_t1->reference,
735 fb_ctrs_t0->reference);
736 delta_delivered = get_delta(fb_ctrs_t1->delivered,
737 fb_ctrs_t0->delivered);
738
739 /*
740 * Avoid divide-by zero and unchanged feedback counters.
741 * Leave it for callers to handle.
742 */
743 if (!delta_reference || !delta_delivered)
744 return 0;
745
746 return (reference_perf * delta_delivered) / delta_reference;
747}
748
749static int cppc_get_perf_ctrs_sample(int cpu,
750 struct cppc_perf_fb_ctrs *fb_ctrs_t0,
751 struct cppc_perf_fb_ctrs *fb_ctrs_t1)
752{
753 int ret;
754
755 ret = cppc_get_perf_ctrs(cpu, fb_ctrs_t0);
756 if (ret)
757 return ret;
758
759 udelay(2); /* 2usec delay between sampling */
760
761 return cppc_get_perf_ctrs(cpu, fb_ctrs_t1);
762}
763
764static unsigned int cppc_cpufreq_get_rate(unsigned int cpu)
765{
766 struct cpufreq_policy *policy __free(put_cpufreq_policy) = cpufreq_cpu_get(cpu);
767 struct cppc_perf_fb_ctrs fb_ctrs_t0 = {0}, fb_ctrs_t1 = {0};
768 struct cppc_cpudata *cpu_data;
769 u64 delivered_perf;
770 int ret;
771
772 if (!policy)
773 return 0;
774
775 cpu_data = policy->driver_data;
776
777 ret = cppc_get_perf_ctrs_sample(cpu, &fb_ctrs_t0, &fb_ctrs_t1);
778 if (ret) {
779 if (ret == -EFAULT)
780 /* Any of the associated CPPC regs is 0. */
781 goto out_invalid_counters;
782 else
783 return 0;
784 }
785
786 delivered_perf = cppc_perf_from_fbctrs(&fb_ctrs_t0, &fb_ctrs_t1);
787 if (!delivered_perf)
788 goto out_invalid_counters;
789
790 return cppc_perf_to_khz(&cpu_data->perf_caps, delivered_perf);
791
792out_invalid_counters:
793 /*
794 * Feedback counters could be unchanged or 0 when a cpu enters a
795 * low-power idle state, e.g. clock-gated or power-gated.
796 * Use desired perf for reflecting frequency. Get the latest register
797 * value first as some platforms may update the actual delivered perf
798 * there; if failed, resort to the cached desired perf.
799 */
800 if (cppc_get_desired_perf(cpu, &delivered_perf))
801 delivered_perf = cpu_data->perf_ctrls.desired_perf;
802
803 return cppc_perf_to_khz(&cpu_data->perf_caps, delivered_perf);
804}
805
806static int cppc_cpufreq_set_boost(struct cpufreq_policy *policy, int state)
807{
808 struct cppc_cpudata *cpu_data = policy->driver_data;
809 struct cppc_perf_caps *caps = &cpu_data->perf_caps;
810 int ret;
811
812 if (state)
813 policy->max = cppc_perf_to_khz(caps, caps->highest_perf);
814 else
815 policy->max = cppc_perf_to_khz(caps, caps->nominal_perf);
816 policy->cpuinfo.max_freq = policy->max;
817
818 ret = freq_qos_update_request(policy->max_freq_req, policy->max);
819 if (ret < 0)
820 return ret;
821
822 return 0;
823}
824
825static ssize_t show_freqdomain_cpus(struct cpufreq_policy *policy, char *buf)
826{
827 struct cppc_cpudata *cpu_data = policy->driver_data;
828
829 return cpufreq_show_cpus(cpu_data->shared_cpu_map, buf);
830}
831
832static ssize_t show_auto_select(struct cpufreq_policy *policy, char *buf)
833{
834 bool val;
835 int ret;
836
837 ret = cppc_get_auto_sel(policy->cpu, &val);
838
839 /* show "<unsupported>" when this register is not supported by cpc */
840 if (ret == -EOPNOTSUPP)
841 return sysfs_emit(buf, "<unsupported>\n");
842
843 if (ret)
844 return ret;
845
846 return sysfs_emit(buf, "%d\n", val);
847}
848
849static ssize_t store_auto_select(struct cpufreq_policy *policy,
850 const char *buf, size_t count)
851{
852 bool val;
853 int ret;
854
855 ret = kstrtobool(buf, &val);
856 if (ret)
857 return ret;
858
859 ret = cppc_set_auto_sel(policy->cpu, val);
860 if (ret)
861 return ret;
862
863 return count;
864}
865
866static ssize_t cppc_cpufreq_sysfs_show_u64(unsigned int cpu,
867 int (*get_func)(int, u64 *),
868 char *buf)
869{
870 u64 val;
871 int ret = get_func((int)cpu, &val);
872
873 if (ret == -EOPNOTSUPP)
874 return sysfs_emit(buf, "<unsupported>\n");
875
876 if (ret)
877 return ret;
878
879 return sysfs_emit(buf, "%llu\n", val);
880}
881
882static ssize_t cppc_cpufreq_sysfs_store_u64(unsigned int cpu,
883 int (*set_func)(int, u64),
884 const char *buf, size_t count)
885{
886 u64 val;
887 int ret;
888
889 ret = kstrtou64(buf, 0, &val);
890 if (ret)
891 return ret;
892
893 ret = set_func((int)cpu, val);
894
895 return ret ? ret : count;
896}
897
898#define CPPC_CPUFREQ_ATTR_RW_U64(_name, _get_func, _set_func) \
899static ssize_t show_##_name(struct cpufreq_policy *policy, char *buf) \
900{ \
901 return cppc_cpufreq_sysfs_show_u64(policy->cpu, _get_func, buf);\
902} \
903static ssize_t store_##_name(struct cpufreq_policy *policy, \
904 const char *buf, size_t count) \
905{ \
906 return cppc_cpufreq_sysfs_store_u64(policy->cpu, _set_func, \
907 buf, count); \
908}
909
910CPPC_CPUFREQ_ATTR_RW_U64(auto_act_window, cppc_get_auto_act_window,
911 cppc_set_auto_act_window)
912
913CPPC_CPUFREQ_ATTR_RW_U64(energy_performance_preference_val,
914 cppc_get_epp_perf, cppc_set_epp)
915
916cpufreq_freq_attr_ro(freqdomain_cpus);
917cpufreq_freq_attr_rw(auto_select);
918cpufreq_freq_attr_rw(auto_act_window);
919cpufreq_freq_attr_rw(energy_performance_preference_val);
920
921static struct freq_attr *cppc_cpufreq_attr[] = {
922 &freqdomain_cpus,
923 &auto_select,
924 &auto_act_window,
925 &energy_performance_preference_val,
926 NULL,
927};
928
929static struct cpufreq_driver cppc_cpufreq_driver = {
930 .flags = CPUFREQ_CONST_LOOPS | CPUFREQ_NEED_UPDATE_LIMITS,
931 .verify = cppc_verify_policy,
932 .target = cppc_cpufreq_set_target,
933 .get = cppc_cpufreq_get_rate,
934 .fast_switch = cppc_cpufreq_fast_switch,
935 .init = cppc_cpufreq_cpu_init,
936 .exit = cppc_cpufreq_cpu_exit,
937 .set_boost = cppc_cpufreq_set_boost,
938 .attr = cppc_cpufreq_attr,
939 .name = "cppc_cpufreq",
940};
941
942static int __init cppc_cpufreq_init(void)
943{
944 int ret;
945
946 if (!acpi_cpc_valid())
947 return -ENODEV;
948
949 cppc_freq_invariance_init();
950 populate_efficiency_class();
951
952 ret = cpufreq_register_driver(&cppc_cpufreq_driver);
953 if (ret)
954 cppc_freq_invariance_exit();
955
956 return ret;
957}
958
959static void __exit cppc_cpufreq_exit(void)
960{
961 cpufreq_unregister_driver(&cppc_cpufreq_driver);
962 cppc_freq_invariance_exit();
963}
964
965module_exit(cppc_cpufreq_exit);
966MODULE_AUTHOR("Ashwin Chaugule");
967MODULE_DESCRIPTION("CPUFreq driver based on the ACPI CPPC v5.0+ spec");
968MODULE_LICENSE("GPL");
969
970late_initcall(cppc_cpufreq_init);
971
972static const struct acpi_device_id cppc_acpi_ids[] __used = {
973 {ACPI_PROCESSOR_DEVICE_HID, },
974 {}
975};
976
977MODULE_DEVICE_TABLE(acpi, cppc_acpi_ids);