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