drivers/acpi/processor_thermal.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * processor_thermal.c - Passive cooling submodule of the ACPI processor driver
   4  *
   5  *  Copyright (C) 2001, 2002 Andy Grover <[email protected]>
   6  *  Copyright (C) 2001, 2002 Paul Diefenbaugh <[email protected]>
   7  *  Copyright (C) 2004       Dominik Brodowski <[email protected]>
   8  *  Copyright (C) 2004  Anil S Keshavamurthy <[email protected]>
   9  *                      - Added processor hotplug support
  10  */
  11
  12 #include <linux/kernel.h>
  13 #include <linux/module.h>
  14 #include <linux/init.h>
  15 #include <linux/cpufreq.h>
  16 #include <linux/acpi.h>
  17 #include <acpi/processor.h>
  18 #include <linux/uaccess.h>
  19
  20 #ifdef CONFIG_CPU_FREQ
  21
  22 /* If a passive cooling situation is detected, primarily CPUfreq is used, as it
  23  * offers (in most cases) voltage scaling in addition to frequency scaling, and
  24  * thus a cubic (instead of linear) reduction of energy. Also, we allow for
  25  * _any_ cpufreq driver and not only the acpi-cpufreq driver.
  26  */
  27
  28 #define CPUFREQ_THERMAL_MIN_STEP 0
  29 #define CPUFREQ_THERMAL_MAX_STEP 3
  30
  31 static DEFINE_PER_CPU(unsigned int, cpufreq_thermal_reduction_pctg);
  32
  33 #define reduction_pctg(cpu) \
  34         per_cpu(cpufreq_thermal_reduction_pctg, phys_package_first_cpu(cpu))
  35
  36 /*
  37  * Emulate "per package data" using per cpu data (which should really be
  38  * provided elsewhere)
  39  *
  40  * Note we can lose a CPU on cpu hotunplug, in this case we forget the state
  41  * temporarily. Fortunately that's not a big issue here (I hope)
  42  */
  43 static int phys_package_first_cpu(int cpu)
  44 {
  45         int i;
  46         int id = topology_physical_package_id(cpu);
  47
  48         for_each_online_cpu(i)
  49                 if (topology_physical_package_id(i) == id)
  50                         return i;
  51         return 0;
  52 }
  53
  54 static int cpu_has_cpufreq(unsigned int cpu)
  55 {
  56         struct cpufreq_policy policy;
  57         if (!acpi_processor_cpufreq_init || cpufreq_get_policy(&policy, cpu))
  58                 return 0;
  59         return 1;
  60 }
  61
  62 static int cpufreq_get_max_state(unsigned int cpu)
  63 {
  64         if (!cpu_has_cpufreq(cpu))
  65                 return 0;
  66
  67         return CPUFREQ_THERMAL_MAX_STEP;
  68 }
  69
  70 static int cpufreq_get_cur_state(unsigned int cpu)
  71 {
  72         if (!cpu_has_cpufreq(cpu))
  73                 return 0;
  74
  75         return reduction_pctg(cpu);
  76 }
  77
  78 static int cpufreq_set_cur_state(unsigned int cpu, int state)
  79 {
  80         struct cpufreq_policy *policy;
  81         struct acpi_processor *pr;
  82         unsigned long max_freq;
  83         int i, ret;
  84
  85         if (!cpu_has_cpufreq(cpu))
  86                 return 0;
  87
  88         reduction_pctg(cpu) = state;
  89
  90         /*
  91          * Update all the CPUs in the same package because they all
  92          * contribute to the temperature and often share the same
  93          * frequency.
  94          */
  95         for_each_online_cpu(i) {
  96                 if (topology_physical_package_id(i) !=
  97                     topology_physical_package_id(cpu))
  98                         continue;
  99
 100                 pr = per_cpu(processors, i);
 101
 102                 if (unlikely(!freq_qos_request_active(&pr->thermal_req)))
 103                         continue;
 104
 105                 policy = cpufreq_cpu_get(i);
 106                 if (!policy)
 107                         return -EINVAL;
 108
 109                 max_freq = (policy->cpuinfo.max_freq * (100 - reduction_pctg(i) * 20)) / 100;
 110
 111                 cpufreq_cpu_put(policy);
 112
 113                 ret = freq_qos_update_request(&pr->thermal_req, max_freq);
 114                 if (ret < 0) {
 115                         pr_warn("Failed to update thermal freq constraint: CPU%d (%d)\n",
 116                                 pr->id, ret);
 117                 }
 118         }
 119         return 0;
 120 }
 121
 122 void acpi_thermal_cpufreq_init(struct cpufreq_policy *policy)
 123 {
 124         unsigned int cpu;
 125
 126         for_each_cpu(cpu, policy->related_cpus) {
 127                 struct acpi_processor *pr = per_cpu(processors, cpu);
 128                 int ret;
 129
 130                 if (!pr)
 131                         continue;
 132
 133                 ret = freq_qos_add_request(&policy->constraints,
 134                                            &pr->thermal_req,
 135                                            FREQ_QOS_MAX, INT_MAX);
 136                 if (ret < 0)
 137                         pr_err("Failed to add freq constraint for CPU%d (%d)\n",
 138                                cpu, ret);
 139         }
 140 }
 141
 142 void acpi_thermal_cpufreq_exit(struct cpufreq_policy *policy)
 143 {
 144         unsigned int cpu;
 145
 146         for_each_cpu(cpu, policy->related_cpus) {
 147                 struct acpi_processor *pr = per_cpu(processors, policy->cpu);
 148
 149                 if (pr)
 150                         freq_qos_remove_request(&pr->thermal_req);
 151         }
 152 }
 153 #else                           /* ! CONFIG_CPU_FREQ */
 154 static int cpufreq_get_max_state(unsigned int cpu)
 155 {
 156         return 0;
 157 }
 158
 159 static int cpufreq_get_cur_state(unsigned int cpu)
 160 {
 161         return 0;
 162 }
 163
 164 static int cpufreq_set_cur_state(unsigned int cpu, int state)
 165 {
 166         return 0;
 167 }
 168
 169 #endif
 170
 171 /* thermal cooling device callbacks */
 172 static int acpi_processor_max_state(struct acpi_processor *pr)
 173 {
 174         int max_state = 0;
 175
 176         /*
 177          * There exists four states according to
 178          * cpufreq_thermal_reduction_pctg. 0, 1, 2, 3
 179          */
 180         max_state += cpufreq_get_max_state(pr->id);
 181         if (pr->flags.throttling)
 182                 max_state += (pr->throttling.state_count -1);
 183
 184         return max_state;
 185 }
 186 static int
 187 processor_get_max_state(struct thermal_cooling_device *cdev,
 188                         unsigned long *state)
 189 {
 190         struct acpi_device *device = cdev->devdata;
 191         struct acpi_processor *pr;
 192
 193         if (!device)
 194                 return -EINVAL;
 195
 196         pr = acpi_driver_data(device);
 197         if (!pr)
 198                 return -EINVAL;
 199
 200         *state = acpi_processor_max_state(pr);
 201         return 0;
 202 }
 203
 204 static int
 205 processor_get_cur_state(struct thermal_cooling_device *cdev,
 206                         unsigned long *cur_state)
 207 {
 208         struct acpi_device *device = cdev->devdata;
 209         struct acpi_processor *pr;
 210
 211         if (!device)
 212                 return -EINVAL;
 213
 214         pr = acpi_driver_data(device);
 215         if (!pr)
 216                 return -EINVAL;
 217
 218         *cur_state = cpufreq_get_cur_state(pr->id);
 219         if (pr->flags.throttling)
 220                 *cur_state += pr->throttling.state;
 221         return 0;
 222 }
 223
 224 static int
 225 processor_set_cur_state(struct thermal_cooling_device *cdev,
 226                         unsigned long state)
 227 {
 228         struct acpi_device *device = cdev->devdata;
 229         struct acpi_processor *pr;
 230         int result = 0;
 231         int max_pstate;
 232
 233         if (!device)
 234                 return -EINVAL;
 235
 236         pr = acpi_driver_data(device);
 237         if (!pr)
 238                 return -EINVAL;
 239
 240         max_pstate = cpufreq_get_max_state(pr->id);
 241
 242         if (state > acpi_processor_max_state(pr))
 243                 return -EINVAL;
 244
 245         if (state <= max_pstate) {
 246                 if (pr->flags.throttling && pr->throttling.state)
 247                         result = acpi_processor_set_throttling(pr, 0, false);
 248                 cpufreq_set_cur_state(pr->id, state);
 249         } else {
 250                 cpufreq_set_cur_state(pr->id, max_pstate);
 251                 result = acpi_processor_set_throttling(pr,
 252                                 state - max_pstate, false);
 253         }
 254         return result;
 255 }
 256
 257 const struct thermal_cooling_device_ops processor_cooling_ops = {
 258         .get_max_state = processor_get_max_state,
 259         .get_cur_state = processor_get_cur_state,
 260         .set_cur_state = processor_set_cur_state,
 261 };