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 * You should have received a copy of the GNU General Public License along 23 * with this program; if not, write to the Free Software Foundation, Inc., 24 * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. 25 * 26 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 27 */ 28 29 #include <linux/kernel.h> 30 #include <linux/module.h> 31 #include <linux/init.h> 32 #include <linux/cpufreq.h> 33 #include <linux/proc_fs.h> 34 #include <linux/seq_file.h> 35 36 #include <asm/uaccess.h> 37 38 #include <acpi/acpi_bus.h> 39 #include <acpi/processor.h> 40 #include <acpi/acpi_drivers.h> 41 42 #define ACPI_PROCESSOR_COMPONENT 0x01000000 43 #define ACPI_PROCESSOR_CLASS "processor" 44 #define ACPI_PROCESSOR_DRIVER_NAME "ACPI Processor Driver" 45 #define _COMPONENT ACPI_PROCESSOR_COMPONENT 46 ACPI_MODULE_NAME("acpi_processor") 47 48 /* -------------------------------------------------------------------------- 49 Limit Interface 50 -------------------------------------------------------------------------- */ 51 static int acpi_processor_apply_limit(struct acpi_processor *pr) 52 { 53 int result = 0; 54 u16 px = 0; 55 u16 tx = 0; 56 57 ACPI_FUNCTION_TRACE("acpi_processor_apply_limit"); 58 59 if (!pr) 60 return_VALUE(-EINVAL); 61 62 if (!pr->flags.limit) 63 return_VALUE(-ENODEV); 64 65 if (pr->flags.throttling) { 66 if (pr->limit.user.tx > tx) 67 tx = pr->limit.user.tx; 68 if (pr->limit.thermal.tx > tx) 69 tx = pr->limit.thermal.tx; 70 71 result = acpi_processor_set_throttling(pr, tx); 72 if (result) 73 goto end; 74 } 75 76 pr->limit.state.px = px; 77 pr->limit.state.tx = tx; 78 79 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 80 "Processor [%d] limit set to (P%d:T%d)\n", pr->id, 81 pr->limit.state.px, pr->limit.state.tx)); 82 83 end: 84 if (result) 85 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Unable to set limit\n")); 86 87 return_VALUE(result); 88 } 89 90 #ifdef CONFIG_CPU_FREQ 91 92 /* If a passive cooling situation is detected, primarily CPUfreq is used, as it 93 * offers (in most cases) voltage scaling in addition to frequency scaling, and 94 * thus a cubic (instead of linear) reduction of energy. Also, we allow for 95 * _any_ cpufreq driver and not only the acpi-cpufreq driver. 96 */ 97 98 static unsigned int cpufreq_thermal_reduction_pctg[NR_CPUS]; 99 static unsigned int acpi_thermal_cpufreq_is_init = 0; 100 101 static int cpu_has_cpufreq(unsigned int cpu) 102 { 103 struct cpufreq_policy policy; 104 if (!acpi_thermal_cpufreq_is_init) 105 return -ENODEV; 106 if (!cpufreq_get_policy(&policy, cpu)) 107 return -ENODEV; 108 return 0; 109 } 110 111 static int acpi_thermal_cpufreq_increase(unsigned int cpu) 112 { 113 if (!cpu_has_cpufreq(cpu)) 114 return -ENODEV; 115 116 if (cpufreq_thermal_reduction_pctg[cpu] < 60) { 117 cpufreq_thermal_reduction_pctg[cpu] += 20; 118 cpufreq_update_policy(cpu); 119 return 0; 120 } 121 122 return -ERANGE; 123 } 124 125 static int acpi_thermal_cpufreq_decrease(unsigned int cpu) 126 { 127 if (!cpu_has_cpufreq(cpu)) 128 return -ENODEV; 129 130 if (cpufreq_thermal_reduction_pctg[cpu] >= 20) { 131 cpufreq_thermal_reduction_pctg[cpu] -= 20; 132 cpufreq_update_policy(cpu); 133 return 0; 134 } 135 136 return -ERANGE; 137 } 138 139 static int acpi_thermal_cpufreq_notifier(struct notifier_block *nb, 140 unsigned long event, void *data) 141 { 142 struct cpufreq_policy *policy = data; 143 unsigned long max_freq = 0; 144 145 if (event != CPUFREQ_ADJUST) 146 goto out; 147 148 max_freq = 149 (policy->cpuinfo.max_freq * 150 (100 - cpufreq_thermal_reduction_pctg[policy->cpu])) / 100; 151 152 cpufreq_verify_within_limits(policy, 0, max_freq); 153 154 out: 155 return 0; 156 } 157 158 static struct notifier_block acpi_thermal_cpufreq_notifier_block = { 159 .notifier_call = acpi_thermal_cpufreq_notifier, 160 }; 161 162 void acpi_thermal_cpufreq_init(void) 163 { 164 int i; 165 166 for (i = 0; i < NR_CPUS; i++) 167 cpufreq_thermal_reduction_pctg[i] = 0; 168 169 i = cpufreq_register_notifier(&acpi_thermal_cpufreq_notifier_block, 170 CPUFREQ_POLICY_NOTIFIER); 171 if (!i) 172 acpi_thermal_cpufreq_is_init = 1; 173 } 174 175 void acpi_thermal_cpufreq_exit(void) 176 { 177 if (acpi_thermal_cpufreq_is_init) 178 cpufreq_unregister_notifier 179 (&acpi_thermal_cpufreq_notifier_block, 180 CPUFREQ_POLICY_NOTIFIER); 181 182 acpi_thermal_cpufreq_is_init = 0; 183 } 184 185 #else /* ! CONFIG_CPU_FREQ */ 186 187 static int acpi_thermal_cpufreq_increase(unsigned int cpu) 188 { 189 return -ENODEV; 190 } 191 static int acpi_thermal_cpufreq_decrease(unsigned int cpu) 192 { 193 return -ENODEV; 194 } 195 196 #endif 197 198 int acpi_processor_set_thermal_limit(acpi_handle handle, int type) 199 { 200 int result = 0; 201 struct acpi_processor *pr = NULL; 202 struct acpi_device *device = NULL; 203 int tx = 0; 204 205 ACPI_FUNCTION_TRACE("acpi_processor_set_thermal_limit"); 206 207 if ((type < ACPI_PROCESSOR_LIMIT_NONE) 208 || (type > ACPI_PROCESSOR_LIMIT_DECREMENT)) 209 return_VALUE(-EINVAL); 210 211 result = acpi_bus_get_device(handle, &device); 212 if (result) 213 return_VALUE(result); 214 215 pr = (struct acpi_processor *)acpi_driver_data(device); 216 if (!pr) 217 return_VALUE(-ENODEV); 218 219 /* Thermal limits are always relative to the current Px/Tx state. */ 220 if (pr->flags.throttling) 221 pr->limit.thermal.tx = pr->throttling.state; 222 223 /* 224 * Our default policy is to only use throttling at the lowest 225 * performance state. 226 */ 227 228 tx = pr->limit.thermal.tx; 229 230 switch (type) { 231 232 case ACPI_PROCESSOR_LIMIT_NONE: 233 do { 234 result = acpi_thermal_cpufreq_decrease(pr->id); 235 } while (!result); 236 tx = 0; 237 break; 238 239 case ACPI_PROCESSOR_LIMIT_INCREMENT: 240 /* if going up: P-states first, T-states later */ 241 242 result = acpi_thermal_cpufreq_increase(pr->id); 243 if (!result) 244 goto end; 245 else if (result == -ERANGE) 246 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 247 "At maximum performance state\n")); 248 249 if (pr->flags.throttling) { 250 if (tx == (pr->throttling.state_count - 1)) 251 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 252 "At maximum throttling state\n")); 253 else 254 tx++; 255 } 256 break; 257 258 case ACPI_PROCESSOR_LIMIT_DECREMENT: 259 /* if going down: T-states first, P-states later */ 260 261 if (pr->flags.throttling) { 262 if (tx == 0) 263 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 264 "At minimum throttling state\n")); 265 else { 266 tx--; 267 goto end; 268 } 269 } 270 271 result = acpi_thermal_cpufreq_decrease(pr->id); 272 if (result == -ERANGE) 273 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 274 "At minimum performance state\n")); 275 276 break; 277 } 278 279 end: 280 if (pr->flags.throttling) { 281 pr->limit.thermal.px = 0; 282 pr->limit.thermal.tx = tx; 283 284 result = acpi_processor_apply_limit(pr); 285 if (result) 286 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, 287 "Unable to set thermal limit\n")); 288 289 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Thermal limit now (P%d:T%d)\n", 290 pr->limit.thermal.px, pr->limit.thermal.tx)); 291 } else 292 result = 0; 293 294 return_VALUE(result); 295 } 296 297 int acpi_processor_get_limit_info(struct acpi_processor *pr) 298 { 299 ACPI_FUNCTION_TRACE("acpi_processor_get_limit_info"); 300 301 if (!pr) 302 return_VALUE(-EINVAL); 303 304 if (pr->flags.throttling) 305 pr->flags.limit = 1; 306 307 return_VALUE(0); 308 } 309 310 /* /proc interface */ 311 312 static int acpi_processor_limit_seq_show(struct seq_file *seq, void *offset) 313 { 314 struct acpi_processor *pr = (struct acpi_processor *)seq->private; 315 316 ACPI_FUNCTION_TRACE("acpi_processor_limit_seq_show"); 317 318 if (!pr) 319 goto end; 320 321 if (!pr->flags.limit) { 322 seq_puts(seq, "<not supported>\n"); 323 goto end; 324 } 325 326 seq_printf(seq, "active limit: P%d:T%d\n" 327 "user limit: P%d:T%d\n" 328 "thermal limit: P%d:T%d\n", 329 pr->limit.state.px, pr->limit.state.tx, 330 pr->limit.user.px, pr->limit.user.tx, 331 pr->limit.thermal.px, pr->limit.thermal.tx); 332 333 end: 334 return_VALUE(0); 335 } 336 337 static int acpi_processor_limit_open_fs(struct inode *inode, struct file *file) 338 { 339 return single_open(file, acpi_processor_limit_seq_show, 340 PDE(inode)->data); 341 } 342 343 ssize_t acpi_processor_write_limit(struct file * file, 344 const char __user * buffer, 345 size_t count, loff_t * data) 346 { 347 int result = 0; 348 struct seq_file *m = (struct seq_file *)file->private_data; 349 struct acpi_processor *pr = (struct acpi_processor *)m->private; 350 char limit_string[25] = { '\0' }; 351 int px = 0; 352 int tx = 0; 353 354 ACPI_FUNCTION_TRACE("acpi_processor_write_limit"); 355 356 if (!pr || (count > sizeof(limit_string) - 1)) { 357 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid argument\n")); 358 return_VALUE(-EINVAL); 359 } 360 361 if (copy_from_user(limit_string, buffer, count)) { 362 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid data\n")); 363 return_VALUE(-EFAULT); 364 } 365 366 limit_string[count] = '\0'; 367 368 if (sscanf(limit_string, "%d:%d", &px, &tx) != 2) { 369 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid data format\n")); 370 return_VALUE(-EINVAL); 371 } 372 373 if (pr->flags.throttling) { 374 if ((tx < 0) || (tx > (pr->throttling.state_count - 1))) { 375 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid tx\n")); 376 return_VALUE(-EINVAL); 377 } 378 pr->limit.user.tx = tx; 379 } 380 381 result = acpi_processor_apply_limit(pr); 382 383 return_VALUE(count); 384 } 385 386 struct file_operations acpi_processor_limit_fops = { 387 .open = acpi_processor_limit_open_fs, 388 .read = seq_read, 389 .llseek = seq_lseek, 390 .release = single_release, 391 }; 392