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 <andrew.grover@intel.com> 6 * Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com> 7 * Copyright (C) 2004 Dominik Brodowski <linux@brodo.de> 8 * Copyright (C) 2004 Anil S Keshavamurthy <anil.s.keshavamurthy@intel.com> 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 58 if (!acpi_processor_cpufreq_init) 59 return 0; 60 61 policy = cpufreq_cpu_get(cpu); 62 if (policy) { 63 cpufreq_cpu_put(policy); 64 return 1; 65 } 66 return 0; 67 } 68 69 static int cpufreq_get_max_state(unsigned int cpu) 70 { 71 if (!cpu_has_cpufreq(cpu)) 72 return 0; 73 74 return CPUFREQ_THERMAL_MAX_STEP; 75 } 76 77 static int cpufreq_get_cur_state(unsigned int cpu) 78 { 79 if (!cpu_has_cpufreq(cpu)) 80 return 0; 81 82 return reduction_pctg(cpu); 83 } 84 85 static int cpufreq_set_cur_state(unsigned int cpu, int state) 86 { 87 struct cpufreq_policy *policy; 88 struct acpi_processor *pr; 89 unsigned long max_freq; 90 int i, ret; 91 92 if (!cpu_has_cpufreq(cpu)) 93 return 0; 94 95 reduction_pctg(cpu) = state; 96 97 /* 98 * Update all the CPUs in the same package because they all 99 * contribute to the temperature and often share the same 100 * frequency. 101 */ 102 for_each_online_cpu(i) { 103 if (topology_physical_package_id(i) != 104 topology_physical_package_id(cpu)) 105 continue; 106 107 pr = per_cpu(processors, i); 108 109 if (unlikely(!freq_qos_request_active(&pr->thermal_req))) 110 continue; 111 112 policy = cpufreq_cpu_get(i); 113 if (!policy) 114 return -EINVAL; 115 116 max_freq = (policy->cpuinfo.max_freq * (100 - reduction_pctg(i) * 20)) / 100; 117 118 cpufreq_cpu_put(policy); 119 120 ret = freq_qos_update_request(&pr->thermal_req, max_freq); 121 if (ret < 0) { 122 pr_warn("Failed to update thermal freq constraint: CPU%d (%d)\n", 123 pr->id, ret); 124 } 125 } 126 return 0; 127 } 128 129 void acpi_thermal_cpufreq_init(struct cpufreq_policy *policy) 130 { 131 unsigned int cpu; 132 133 for_each_cpu(cpu, policy->related_cpus) { 134 struct acpi_processor *pr = per_cpu(processors, cpu); 135 int ret; 136 137 if (!pr) 138 continue; 139 140 ret = freq_qos_add_request(&policy->constraints, 141 &pr->thermal_req, 142 FREQ_QOS_MAX, INT_MAX); 143 if (ret < 0) 144 pr_err("Failed to add freq constraint for CPU%d (%d)\n", 145 cpu, ret); 146 } 147 } 148 149 void acpi_thermal_cpufreq_exit(struct cpufreq_policy *policy) 150 { 151 unsigned int cpu; 152 153 for_each_cpu(cpu, policy->related_cpus) { 154 struct acpi_processor *pr = per_cpu(processors, cpu); 155 156 if (pr) 157 freq_qos_remove_request(&pr->thermal_req); 158 } 159 } 160 #else /* ! CONFIG_CPU_FREQ */ 161 static int cpufreq_get_max_state(unsigned int cpu) 162 { 163 return 0; 164 } 165 166 static int cpufreq_get_cur_state(unsigned int cpu) 167 { 168 return 0; 169 } 170 171 static int cpufreq_set_cur_state(unsigned int cpu, int state) 172 { 173 return 0; 174 } 175 176 #endif 177 178 /* thermal cooling device callbacks */ 179 static int acpi_processor_max_state(struct acpi_processor *pr) 180 { 181 int max_state = 0; 182 183 /* 184 * There exists four states according to 185 * cpufreq_thermal_reduction_pctg. 0, 1, 2, 3 186 */ 187 max_state += cpufreq_get_max_state(pr->id); 188 if (pr->flags.throttling) 189 max_state += (pr->throttling.state_count -1); 190 191 return max_state; 192 } 193 static int 194 processor_get_max_state(struct thermal_cooling_device *cdev, 195 unsigned long *state) 196 { 197 struct acpi_device *device = cdev->devdata; 198 struct acpi_processor *pr; 199 200 if (!device) 201 return -EINVAL; 202 203 pr = acpi_driver_data(device); 204 if (!pr) 205 return -EINVAL; 206 207 *state = acpi_processor_max_state(pr); 208 return 0; 209 } 210 211 static int 212 processor_get_cur_state(struct thermal_cooling_device *cdev, 213 unsigned long *cur_state) 214 { 215 struct acpi_device *device = cdev->devdata; 216 struct acpi_processor *pr; 217 218 if (!device) 219 return -EINVAL; 220 221 pr = acpi_driver_data(device); 222 if (!pr) 223 return -EINVAL; 224 225 *cur_state = cpufreq_get_cur_state(pr->id); 226 if (pr->flags.throttling) 227 *cur_state += pr->throttling.state; 228 return 0; 229 } 230 231 static int 232 processor_set_cur_state(struct thermal_cooling_device *cdev, 233 unsigned long state) 234 { 235 struct acpi_device *device = cdev->devdata; 236 struct acpi_processor *pr; 237 int result = 0; 238 int max_pstate; 239 240 if (!device) 241 return -EINVAL; 242 243 pr = acpi_driver_data(device); 244 if (!pr) 245 return -EINVAL; 246 247 max_pstate = cpufreq_get_max_state(pr->id); 248 249 if (state > acpi_processor_max_state(pr)) 250 return -EINVAL; 251 252 if (state <= max_pstate) { 253 if (pr->flags.throttling && pr->throttling.state) 254 result = acpi_processor_set_throttling(pr, 0, false); 255 cpufreq_set_cur_state(pr->id, state); 256 } else { 257 cpufreq_set_cur_state(pr->id, max_pstate); 258 result = acpi_processor_set_throttling(pr, 259 state - max_pstate, false); 260 } 261 return result; 262 } 263 264 const struct thermal_cooling_device_ops processor_cooling_ops = { 265 .get_max_state = processor_get_max_state, 266 .get_cur_state = processor_get_cur_state, 267 .set_cur_state = processor_set_cur_state, 268 }; 269 270 int acpi_processor_thermal_init(struct acpi_processor *pr, 271 struct acpi_device *device) 272 { 273 int result = 0; 274 275 pr->cdev = thermal_cooling_device_register("Processor", device, 276 &processor_cooling_ops); 277 if (IS_ERR(pr->cdev)) { 278 result = PTR_ERR(pr->cdev); 279 return result; 280 } 281 282 dev_dbg(&device->dev, "registered as cooling_device%d\n", 283 pr->cdev->id); 284 285 result = sysfs_create_link(&device->dev.kobj, 286 &pr->cdev->device.kobj, 287 "thermal_cooling"); 288 if (result) { 289 dev_err(&device->dev, 290 "Failed to create sysfs link 'thermal_cooling'\n"); 291 goto err_thermal_unregister; 292 } 293 294 result = sysfs_create_link(&pr->cdev->device.kobj, 295 &device->dev.kobj, 296 "device"); 297 if (result) { 298 dev_err(&pr->cdev->device, 299 "Failed to create sysfs link 'device'\n"); 300 goto err_remove_sysfs_thermal; 301 } 302 303 return 0; 304 305 err_remove_sysfs_thermal: 306 sysfs_remove_link(&device->dev.kobj, "thermal_cooling"); 307 err_thermal_unregister: 308 thermal_cooling_device_unregister(pr->cdev); 309 310 return result; 311 } 312 313 void acpi_processor_thermal_exit(struct acpi_processor *pr, 314 struct acpi_device *device) 315 { 316 if (pr->cdev) { 317 sysfs_remove_link(&device->dev.kobj, "thermal_cooling"); 318 sysfs_remove_link(&pr->cdev->device.kobj, "device"); 319 thermal_cooling_device_unregister(pr->cdev); 320 pr->cdev = NULL; 321 } 322 } 323