1 /* 2 * processor_thermal.c - Passive cooling submodule of the ACPI processor driver 3 * 4 * Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com> 5 * Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com> 6 * Copyright (C) 2004 Dominik Brodowski <linux@brodo.de> 7 * Copyright (C) 2004 Anil S Keshavamurthy <anil.s.keshavamurthy@intel.com> 8 * - Added processor hotplug support 9 * 10 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 11 * 12 * This program is free software; you can redistribute it and/or modify 13 * it under the terms of the GNU General Public License as published by 14 * the Free Software Foundation; either version 2 of the License, or (at 15 * your option) any later version. 16 * 17 * This program is distributed in the hope that it will be useful, but 18 * WITHOUT ANY WARRANTY; without even the implied warranty of 19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 20 * General Public License for more details. 21 * 22 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 23 */ 24 25 #include <linux/kernel.h> 26 #include <linux/module.h> 27 #include <linux/init.h> 28 #include <linux/cpufreq.h> 29 #include <linux/acpi.h> 30 #include <acpi/processor.h> 31 #include <asm/uaccess.h> 32 33 #define PREFIX "ACPI: " 34 35 #define ACPI_PROCESSOR_CLASS "processor" 36 #define _COMPONENT ACPI_PROCESSOR_COMPONENT 37 ACPI_MODULE_NAME("processor_thermal"); 38 39 #ifdef CONFIG_CPU_FREQ 40 41 /* If a passive cooling situation is detected, primarily CPUfreq is used, as it 42 * offers (in most cases) voltage scaling in addition to frequency scaling, and 43 * thus a cubic (instead of linear) reduction of energy. Also, we allow for 44 * _any_ cpufreq driver and not only the acpi-cpufreq driver. 45 */ 46 47 #define CPUFREQ_THERMAL_MIN_STEP 0 48 #define CPUFREQ_THERMAL_MAX_STEP 3 49 50 static DEFINE_PER_CPU(unsigned int, cpufreq_thermal_reduction_pctg); 51 static unsigned int acpi_thermal_cpufreq_is_init = 0; 52 53 #define reduction_pctg(cpu) \ 54 per_cpu(cpufreq_thermal_reduction_pctg, phys_package_first_cpu(cpu)) 55 56 /* 57 * Emulate "per package data" using per cpu data (which should really be 58 * provided elsewhere) 59 * 60 * Note we can lose a CPU on cpu hotunplug, in this case we forget the state 61 * temporarily. Fortunately that's not a big issue here (I hope) 62 */ 63 static int phys_package_first_cpu(int cpu) 64 { 65 int i; 66 int id = topology_physical_package_id(cpu); 67 68 for_each_online_cpu(i) 69 if (topology_physical_package_id(i) == id) 70 return i; 71 return 0; 72 } 73 74 static int cpu_has_cpufreq(unsigned int cpu) 75 { 76 struct cpufreq_policy policy; 77 if (!acpi_thermal_cpufreq_is_init || cpufreq_get_policy(&policy, cpu)) 78 return 0; 79 return 1; 80 } 81 82 static int acpi_thermal_cpufreq_notifier(struct notifier_block *nb, 83 unsigned long event, void *data) 84 { 85 struct cpufreq_policy *policy = data; 86 unsigned long max_freq = 0; 87 88 if (event != CPUFREQ_ADJUST) 89 goto out; 90 91 max_freq = ( 92 policy->cpuinfo.max_freq * 93 (100 - reduction_pctg(policy->cpu) * 20) 94 ) / 100; 95 96 cpufreq_verify_within_limits(policy, 0, max_freq); 97 98 out: 99 return 0; 100 } 101 102 static struct notifier_block acpi_thermal_cpufreq_notifier_block = { 103 .notifier_call = acpi_thermal_cpufreq_notifier, 104 }; 105 106 static int cpufreq_get_max_state(unsigned int cpu) 107 { 108 if (!cpu_has_cpufreq(cpu)) 109 return 0; 110 111 return CPUFREQ_THERMAL_MAX_STEP; 112 } 113 114 static int cpufreq_get_cur_state(unsigned int cpu) 115 { 116 if (!cpu_has_cpufreq(cpu)) 117 return 0; 118 119 return reduction_pctg(cpu); 120 } 121 122 static int cpufreq_set_cur_state(unsigned int cpu, int state) 123 { 124 int i; 125 126 if (!cpu_has_cpufreq(cpu)) 127 return 0; 128 129 reduction_pctg(cpu) = state; 130 131 /* 132 * Update all the CPUs in the same package because they all 133 * contribute to the temperature and often share the same 134 * frequency. 135 */ 136 for_each_online_cpu(i) { 137 if (topology_physical_package_id(i) == 138 topology_physical_package_id(cpu)) 139 cpufreq_update_policy(i); 140 } 141 return 0; 142 } 143 144 void acpi_thermal_cpufreq_init(void) 145 { 146 int i; 147 148 i = cpufreq_register_notifier(&acpi_thermal_cpufreq_notifier_block, 149 CPUFREQ_POLICY_NOTIFIER); 150 if (!i) 151 acpi_thermal_cpufreq_is_init = 1; 152 } 153 154 void acpi_thermal_cpufreq_exit(void) 155 { 156 if (acpi_thermal_cpufreq_is_init) 157 cpufreq_unregister_notifier 158 (&acpi_thermal_cpufreq_notifier_block, 159 CPUFREQ_POLICY_NOTIFIER); 160 161 acpi_thermal_cpufreq_is_init = 0; 162 } 163 164 #else /* ! CONFIG_CPU_FREQ */ 165 static int cpufreq_get_max_state(unsigned int cpu) 166 { 167 return 0; 168 } 169 170 static int cpufreq_get_cur_state(unsigned int cpu) 171 { 172 return 0; 173 } 174 175 static int cpufreq_set_cur_state(unsigned int cpu, int state) 176 { 177 return 0; 178 } 179 180 #endif 181 182 /* thermal cooling device callbacks */ 183 static int acpi_processor_max_state(struct acpi_processor *pr) 184 { 185 int max_state = 0; 186 187 /* 188 * There exists four states according to 189 * cpufreq_thermal_reduction_pctg. 0, 1, 2, 3 190 */ 191 max_state += cpufreq_get_max_state(pr->id); 192 if (pr->flags.throttling) 193 max_state += (pr->throttling.state_count -1); 194 195 return max_state; 196 } 197 static int 198 processor_get_max_state(struct thermal_cooling_device *cdev, 199 unsigned long *state) 200 { 201 struct acpi_device *device = cdev->devdata; 202 struct acpi_processor *pr; 203 204 if (!device) 205 return -EINVAL; 206 207 pr = acpi_driver_data(device); 208 if (!pr) 209 return -EINVAL; 210 211 *state = acpi_processor_max_state(pr); 212 return 0; 213 } 214 215 static int 216 processor_get_cur_state(struct thermal_cooling_device *cdev, 217 unsigned long *cur_state) 218 { 219 struct acpi_device *device = cdev->devdata; 220 struct acpi_processor *pr; 221 222 if (!device) 223 return -EINVAL; 224 225 pr = acpi_driver_data(device); 226 if (!pr) 227 return -EINVAL; 228 229 *cur_state = cpufreq_get_cur_state(pr->id); 230 if (pr->flags.throttling) 231 *cur_state += pr->throttling.state; 232 return 0; 233 } 234 235 static int 236 processor_set_cur_state(struct thermal_cooling_device *cdev, 237 unsigned long state) 238 { 239 struct acpi_device *device = cdev->devdata; 240 struct acpi_processor *pr; 241 int result = 0; 242 int max_pstate; 243 244 if (!device) 245 return -EINVAL; 246 247 pr = acpi_driver_data(device); 248 if (!pr) 249 return -EINVAL; 250 251 max_pstate = cpufreq_get_max_state(pr->id); 252 253 if (state > acpi_processor_max_state(pr)) 254 return -EINVAL; 255 256 if (state <= max_pstate) { 257 if (pr->flags.throttling && pr->throttling.state) 258 result = acpi_processor_set_throttling(pr, 0, false); 259 cpufreq_set_cur_state(pr->id, state); 260 } else { 261 cpufreq_set_cur_state(pr->id, max_pstate); 262 result = acpi_processor_set_throttling(pr, 263 state - max_pstate, false); 264 } 265 return result; 266 } 267 268 const struct thermal_cooling_device_ops processor_cooling_ops = { 269 .get_max_state = processor_get_max_state, 270 .get_cur_state = processor_get_cur_state, 271 .set_cur_state = processor_set_cur_state, 272 }; 273