Commit | Line | Data |
---|---|---|
1da177e4 LT |
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> | |
d9460fd2 | 35 | #include <linux/sysdev.h> |
1da177e4 LT |
36 | |
37 | #include <asm/uaccess.h> | |
38 | ||
39 | #include <acpi/acpi_bus.h> | |
40 | #include <acpi/processor.h> | |
41 | #include <acpi/acpi_drivers.h> | |
42 | ||
43 | #define ACPI_PROCESSOR_COMPONENT 0x01000000 | |
44 | #define ACPI_PROCESSOR_CLASS "processor" | |
1da177e4 | 45 | #define _COMPONENT ACPI_PROCESSOR_COMPONENT |
f52fd66d | 46 | ACPI_MODULE_NAME("processor_thermal"); |
1da177e4 LT |
47 | |
48 | /* -------------------------------------------------------------------------- | |
49 | Limit Interface | |
50 | -------------------------------------------------------------------------- */ | |
4be44fcd | 51 | static int acpi_processor_apply_limit(struct acpi_processor *pr) |
1da177e4 | 52 | { |
4be44fcd LB |
53 | int result = 0; |
54 | u16 px = 0; | |
55 | u16 tx = 0; | |
1da177e4 | 56 | |
1da177e4 LT |
57 | |
58 | if (!pr) | |
d550d98d | 59 | return -EINVAL; |
1da177e4 LT |
60 | |
61 | if (!pr->flags.limit) | |
d550d98d | 62 | return -ENODEV; |
1da177e4 LT |
63 | |
64 | if (pr->flags.throttling) { | |
65 | if (pr->limit.user.tx > tx) | |
66 | tx = pr->limit.user.tx; | |
67 | if (pr->limit.thermal.tx > tx) | |
68 | tx = pr->limit.thermal.tx; | |
69 | ||
70 | result = acpi_processor_set_throttling(pr, tx); | |
71 | if (result) | |
72 | goto end; | |
73 | } | |
74 | ||
75 | pr->limit.state.px = px; | |
76 | pr->limit.state.tx = tx; | |
77 | ||
4be44fcd LB |
78 | ACPI_DEBUG_PRINT((ACPI_DB_INFO, |
79 | "Processor [%d] limit set to (P%d:T%d)\n", pr->id, | |
80 | pr->limit.state.px, pr->limit.state.tx)); | |
1da177e4 | 81 | |
4be44fcd | 82 | end: |
1da177e4 | 83 | if (result) |
6468463a | 84 | printk(KERN_ERR PREFIX "Unable to set limit\n"); |
1da177e4 | 85 | |
d550d98d | 86 | return result; |
1da177e4 LT |
87 | } |
88 | ||
1da177e4 LT |
89 | #ifdef CONFIG_CPU_FREQ |
90 | ||
91 | /* If a passive cooling situation is detected, primarily CPUfreq is used, as it | |
92 | * offers (in most cases) voltage scaling in addition to frequency scaling, and | |
93 | * thus a cubic (instead of linear) reduction of energy. Also, we allow for | |
94 | * _any_ cpufreq driver and not only the acpi-cpufreq driver. | |
95 | */ | |
96 | ||
d9460fd2 ZR |
97 | #define CPUFREQ_THERMAL_MIN_STEP 0 |
98 | #define CPUFREQ_THERMAL_MAX_STEP 3 | |
99 | ||
c938ac21 | 100 | static DEFINE_PER_CPU(unsigned int, cpufreq_thermal_reduction_pctg); |
1da177e4 LT |
101 | static unsigned int acpi_thermal_cpufreq_is_init = 0; |
102 | ||
1da177e4 LT |
103 | static int cpu_has_cpufreq(unsigned int cpu) |
104 | { | |
105 | struct cpufreq_policy policy; | |
1cbf4c56 | 106 | if (!acpi_thermal_cpufreq_is_init || cpufreq_get_policy(&policy, cpu)) |
75b245b3 TR |
107 | return 0; |
108 | return 1; | |
1da177e4 LT |
109 | } |
110 | ||
1da177e4 LT |
111 | static int acpi_thermal_cpufreq_increase(unsigned int cpu) |
112 | { | |
113 | if (!cpu_has_cpufreq(cpu)) | |
114 | return -ENODEV; | |
115 | ||
c938ac21 | 116 | if (per_cpu(cpufreq_thermal_reduction_pctg, cpu) < |
d9460fd2 | 117 | CPUFREQ_THERMAL_MAX_STEP) { |
c938ac21 | 118 | per_cpu(cpufreq_thermal_reduction_pctg, cpu)++; |
1da177e4 LT |
119 | cpufreq_update_policy(cpu); |
120 | return 0; | |
121 | } | |
122 | ||
123 | return -ERANGE; | |
124 | } | |
125 | ||
1da177e4 LT |
126 | static int acpi_thermal_cpufreq_decrease(unsigned int cpu) |
127 | { | |
128 | if (!cpu_has_cpufreq(cpu)) | |
129 | return -ENODEV; | |
130 | ||
c938ac21 | 131 | if (per_cpu(cpufreq_thermal_reduction_pctg, cpu) > |
d9460fd2 | 132 | (CPUFREQ_THERMAL_MIN_STEP + 1)) |
c938ac21 | 133 | per_cpu(cpufreq_thermal_reduction_pctg, cpu)--; |
1cbf4c56 | 134 | else |
c938ac21 | 135 | per_cpu(cpufreq_thermal_reduction_pctg, cpu) = 0; |
1cbf4c56 TR |
136 | cpufreq_update_policy(cpu); |
137 | /* We reached max freq again and can leave passive mode */ | |
c938ac21 | 138 | return !per_cpu(cpufreq_thermal_reduction_pctg, cpu); |
1da177e4 LT |
139 | } |
140 | ||
4be44fcd LB |
141 | static int acpi_thermal_cpufreq_notifier(struct notifier_block *nb, |
142 | unsigned long event, void *data) | |
1da177e4 LT |
143 | { |
144 | struct cpufreq_policy *policy = data; | |
145 | unsigned long max_freq = 0; | |
146 | ||
147 | if (event != CPUFREQ_ADJUST) | |
148 | goto out; | |
149 | ||
c938ac21 MT |
150 | max_freq = ( |
151 | policy->cpuinfo.max_freq * | |
152 | (100 - per_cpu(cpufreq_thermal_reduction_pctg, policy->cpu) * 20) | |
153 | ) / 100; | |
1da177e4 LT |
154 | |
155 | cpufreq_verify_within_limits(policy, 0, max_freq); | |
156 | ||
4be44fcd | 157 | out: |
1da177e4 LT |
158 | return 0; |
159 | } | |
160 | ||
1da177e4 LT |
161 | static struct notifier_block acpi_thermal_cpufreq_notifier_block = { |
162 | .notifier_call = acpi_thermal_cpufreq_notifier, | |
163 | }; | |
164 | ||
d9460fd2 ZR |
165 | static int cpufreq_get_max_state(unsigned int cpu) |
166 | { | |
167 | if (!cpu_has_cpufreq(cpu)) | |
168 | return 0; | |
169 | ||
170 | return CPUFREQ_THERMAL_MAX_STEP; | |
171 | } | |
172 | ||
173 | static int cpufreq_get_cur_state(unsigned int cpu) | |
174 | { | |
175 | if (!cpu_has_cpufreq(cpu)) | |
176 | return 0; | |
177 | ||
c938ac21 | 178 | return per_cpu(cpufreq_thermal_reduction_pctg, cpu); |
d9460fd2 ZR |
179 | } |
180 | ||
181 | static int cpufreq_set_cur_state(unsigned int cpu, int state) | |
182 | { | |
183 | if (!cpu_has_cpufreq(cpu)) | |
184 | return 0; | |
185 | ||
c938ac21 | 186 | per_cpu(cpufreq_thermal_reduction_pctg, cpu) = state; |
d9460fd2 ZR |
187 | cpufreq_update_policy(cpu); |
188 | return 0; | |
189 | } | |
190 | ||
4be44fcd LB |
191 | void acpi_thermal_cpufreq_init(void) |
192 | { | |
1da177e4 LT |
193 | int i; |
194 | ||
c938ac21 MT |
195 | for (i = 0; i < nr_cpu_ids; i++) |
196 | if (cpu_present(i)) | |
197 | per_cpu(cpufreq_thermal_reduction_pctg, i) = 0; | |
1da177e4 | 198 | |
4be44fcd LB |
199 | i = cpufreq_register_notifier(&acpi_thermal_cpufreq_notifier_block, |
200 | CPUFREQ_POLICY_NOTIFIER); | |
1da177e4 LT |
201 | if (!i) |
202 | acpi_thermal_cpufreq_is_init = 1; | |
203 | } | |
204 | ||
4be44fcd LB |
205 | void acpi_thermal_cpufreq_exit(void) |
206 | { | |
1da177e4 | 207 | if (acpi_thermal_cpufreq_is_init) |
4be44fcd LB |
208 | cpufreq_unregister_notifier |
209 | (&acpi_thermal_cpufreq_notifier_block, | |
210 | CPUFREQ_POLICY_NOTIFIER); | |
1da177e4 LT |
211 | |
212 | acpi_thermal_cpufreq_is_init = 0; | |
213 | } | |
214 | ||
4be44fcd | 215 | #else /* ! CONFIG_CPU_FREQ */ |
d9460fd2 ZR |
216 | static int cpufreq_get_max_state(unsigned int cpu) |
217 | { | |
218 | return 0; | |
219 | } | |
220 | ||
221 | static int cpufreq_get_cur_state(unsigned int cpu) | |
222 | { | |
223 | return 0; | |
224 | } | |
225 | ||
226 | static int cpufreq_set_cur_state(unsigned int cpu, int state) | |
227 | { | |
228 | return 0; | |
229 | } | |
1da177e4 | 230 | |
4be44fcd LB |
231 | static int acpi_thermal_cpufreq_increase(unsigned int cpu) |
232 | { | |
233 | return -ENODEV; | |
234 | } | |
235 | static int acpi_thermal_cpufreq_decrease(unsigned int cpu) | |
236 | { | |
237 | return -ENODEV; | |
238 | } | |
1da177e4 LT |
239 | |
240 | #endif | |
241 | ||
4be44fcd | 242 | int acpi_processor_set_thermal_limit(acpi_handle handle, int type) |
1da177e4 | 243 | { |
4be44fcd LB |
244 | int result = 0; |
245 | struct acpi_processor *pr = NULL; | |
246 | struct acpi_device *device = NULL; | |
1cbf4c56 | 247 | int tx = 0, max_tx_px = 0; |
1da177e4 | 248 | |
1da177e4 LT |
249 | |
250 | if ((type < ACPI_PROCESSOR_LIMIT_NONE) | |
4be44fcd | 251 | || (type > ACPI_PROCESSOR_LIMIT_DECREMENT)) |
d550d98d | 252 | return -EINVAL; |
1da177e4 LT |
253 | |
254 | result = acpi_bus_get_device(handle, &device); | |
255 | if (result) | |
d550d98d | 256 | return result; |
1da177e4 | 257 | |
50dd0969 | 258 | pr = acpi_driver_data(device); |
1da177e4 | 259 | if (!pr) |
d550d98d | 260 | return -ENODEV; |
1da177e4 LT |
261 | |
262 | /* Thermal limits are always relative to the current Px/Tx state. */ | |
263 | if (pr->flags.throttling) | |
264 | pr->limit.thermal.tx = pr->throttling.state; | |
265 | ||
266 | /* | |
267 | * Our default policy is to only use throttling at the lowest | |
268 | * performance state. | |
269 | */ | |
270 | ||
271 | tx = pr->limit.thermal.tx; | |
272 | ||
273 | switch (type) { | |
274 | ||
275 | case ACPI_PROCESSOR_LIMIT_NONE: | |
276 | do { | |
277 | result = acpi_thermal_cpufreq_decrease(pr->id); | |
278 | } while (!result); | |
279 | tx = 0; | |
280 | break; | |
281 | ||
282 | case ACPI_PROCESSOR_LIMIT_INCREMENT: | |
283 | /* if going up: P-states first, T-states later */ | |
284 | ||
285 | result = acpi_thermal_cpufreq_increase(pr->id); | |
286 | if (!result) | |
287 | goto end; | |
288 | else if (result == -ERANGE) | |
289 | ACPI_DEBUG_PRINT((ACPI_DB_INFO, | |
4be44fcd | 290 | "At maximum performance state\n")); |
1da177e4 LT |
291 | |
292 | if (pr->flags.throttling) { | |
293 | if (tx == (pr->throttling.state_count - 1)) | |
294 | ACPI_DEBUG_PRINT((ACPI_DB_INFO, | |
4be44fcd | 295 | "At maximum throttling state\n")); |
1da177e4 LT |
296 | else |
297 | tx++; | |
298 | } | |
299 | break; | |
300 | ||
301 | case ACPI_PROCESSOR_LIMIT_DECREMENT: | |
302 | /* if going down: T-states first, P-states later */ | |
303 | ||
304 | if (pr->flags.throttling) { | |
1cbf4c56 TR |
305 | if (tx == 0) { |
306 | max_tx_px = 1; | |
1da177e4 | 307 | ACPI_DEBUG_PRINT((ACPI_DB_INFO, |
4be44fcd | 308 | "At minimum throttling state\n")); |
1cbf4c56 | 309 | } else { |
1da177e4 LT |
310 | tx--; |
311 | goto end; | |
312 | } | |
313 | } | |
314 | ||
315 | result = acpi_thermal_cpufreq_decrease(pr->id); | |
1cbf4c56 TR |
316 | if (result) { |
317 | /* | |
318 | * We only could get -ERANGE, 1 or 0. | |
319 | * In the first two cases we reached max freq again. | |
320 | */ | |
1da177e4 | 321 | ACPI_DEBUG_PRINT((ACPI_DB_INFO, |
4be44fcd | 322 | "At minimum performance state\n")); |
1cbf4c56 TR |
323 | max_tx_px = 1; |
324 | } else | |
325 | max_tx_px = 0; | |
1da177e4 LT |
326 | |
327 | break; | |
328 | } | |
329 | ||
4be44fcd | 330 | end: |
1da177e4 LT |
331 | if (pr->flags.throttling) { |
332 | pr->limit.thermal.px = 0; | |
333 | pr->limit.thermal.tx = tx; | |
334 | ||
335 | result = acpi_processor_apply_limit(pr); | |
336 | if (result) | |
6468463a | 337 | printk(KERN_ERR PREFIX "Unable to set thermal limit\n"); |
1da177e4 LT |
338 | |
339 | ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Thermal limit now (P%d:T%d)\n", | |
4be44fcd | 340 | pr->limit.thermal.px, pr->limit.thermal.tx)); |
1da177e4 LT |
341 | } else |
342 | result = 0; | |
1cbf4c56 | 343 | if (max_tx_px) |
d550d98d | 344 | return 1; |
1cbf4c56 | 345 | else |
d550d98d | 346 | return result; |
1da177e4 LT |
347 | } |
348 | ||
4be44fcd | 349 | int acpi_processor_get_limit_info(struct acpi_processor *pr) |
1da177e4 | 350 | { |
1da177e4 LT |
351 | |
352 | if (!pr) | |
d550d98d | 353 | return -EINVAL; |
1da177e4 LT |
354 | |
355 | if (pr->flags.throttling) | |
356 | pr->flags.limit = 1; | |
357 | ||
d550d98d | 358 | return 0; |
1da177e4 LT |
359 | } |
360 | ||
d9460fd2 ZR |
361 | /* thermal coolign device callbacks */ |
362 | static int acpi_processor_max_state(struct acpi_processor *pr) | |
363 | { | |
364 | int max_state = 0; | |
365 | ||
366 | /* | |
367 | * There exists four states according to | |
368 | * cpufreq_thermal_reduction_ptg. 0, 1, 2, 3 | |
369 | */ | |
370 | max_state += cpufreq_get_max_state(pr->id); | |
371 | if (pr->flags.throttling) | |
372 | max_state += (pr->throttling.state_count -1); | |
373 | ||
374 | return max_state; | |
375 | } | |
376 | static int | |
377 | processor_get_max_state(struct thermal_cooling_device *cdev, char *buf) | |
378 | { | |
379 | struct acpi_device *device = cdev->devdata; | |
380 | struct acpi_processor *pr = acpi_driver_data(device); | |
381 | ||
382 | if (!device || !pr) | |
383 | return -EINVAL; | |
384 | ||
385 | return sprintf(buf, "%d\n", acpi_processor_max_state(pr)); | |
386 | } | |
387 | ||
388 | static int | |
389 | processor_get_cur_state(struct thermal_cooling_device *cdev, char *buf) | |
390 | { | |
391 | struct acpi_device *device = cdev->devdata; | |
392 | struct acpi_processor *pr = acpi_driver_data(device); | |
393 | int cur_state; | |
394 | ||
395 | if (!device || !pr) | |
396 | return -EINVAL; | |
397 | ||
398 | cur_state = cpufreq_get_cur_state(pr->id); | |
399 | if (pr->flags.throttling) | |
400 | cur_state += pr->throttling.state; | |
401 | ||
402 | return sprintf(buf, "%d\n", cur_state); | |
403 | } | |
404 | ||
405 | static int | |
406 | processor_set_cur_state(struct thermal_cooling_device *cdev, unsigned int state) | |
407 | { | |
408 | struct acpi_device *device = cdev->devdata; | |
409 | struct acpi_processor *pr = acpi_driver_data(device); | |
410 | int result = 0; | |
411 | int max_pstate; | |
412 | ||
413 | if (!device || !pr) | |
414 | return -EINVAL; | |
415 | ||
416 | max_pstate = cpufreq_get_max_state(pr->id); | |
417 | ||
418 | if (state > acpi_processor_max_state(pr)) | |
419 | return -EINVAL; | |
420 | ||
421 | if (state <= max_pstate) { | |
422 | if (pr->flags.throttling && pr->throttling.state) | |
423 | result = acpi_processor_set_throttling(pr, 0); | |
424 | cpufreq_set_cur_state(pr->id, state); | |
425 | } else { | |
426 | cpufreq_set_cur_state(pr->id, max_pstate); | |
427 | result = acpi_processor_set_throttling(pr, | |
428 | state - max_pstate); | |
429 | } | |
430 | return result; | |
431 | } | |
432 | ||
433 | struct thermal_cooling_device_ops processor_cooling_ops = { | |
434 | .get_max_state = processor_get_max_state, | |
435 | .get_cur_state = processor_get_cur_state, | |
436 | .set_cur_state = processor_set_cur_state, | |
437 | }; | |
438 | ||
1da177e4 LT |
439 | /* /proc interface */ |
440 | ||
441 | static int acpi_processor_limit_seq_show(struct seq_file *seq, void *offset) | |
442 | { | |
4be44fcd | 443 | struct acpi_processor *pr = (struct acpi_processor *)seq->private; |
1da177e4 | 444 | |
1da177e4 LT |
445 | |
446 | if (!pr) | |
447 | goto end; | |
448 | ||
449 | if (!pr->flags.limit) { | |
450 | seq_puts(seq, "<not supported>\n"); | |
451 | goto end; | |
452 | } | |
453 | ||
454 | seq_printf(seq, "active limit: P%d:T%d\n" | |
4be44fcd LB |
455 | "user limit: P%d:T%d\n" |
456 | "thermal limit: P%d:T%d\n", | |
457 | pr->limit.state.px, pr->limit.state.tx, | |
458 | pr->limit.user.px, pr->limit.user.tx, | |
459 | pr->limit.thermal.px, pr->limit.thermal.tx); | |
1da177e4 | 460 | |
4be44fcd | 461 | end: |
d550d98d | 462 | return 0; |
1da177e4 LT |
463 | } |
464 | ||
465 | static int acpi_processor_limit_open_fs(struct inode *inode, struct file *file) | |
466 | { | |
467 | return single_open(file, acpi_processor_limit_seq_show, | |
4be44fcd | 468 | PDE(inode)->data); |
1da177e4 LT |
469 | } |
470 | ||
757b1866 AB |
471 | static ssize_t acpi_processor_write_limit(struct file * file, |
472 | const char __user * buffer, | |
473 | size_t count, loff_t * data) | |
1da177e4 | 474 | { |
4be44fcd | 475 | int result = 0; |
50dd0969 JE |
476 | struct seq_file *m = file->private_data; |
477 | struct acpi_processor *pr = m->private; | |
4be44fcd LB |
478 | char limit_string[25] = { '\0' }; |
479 | int px = 0; | |
480 | int tx = 0; | |
1da177e4 | 481 | |
1da177e4 LT |
482 | |
483 | if (!pr || (count > sizeof(limit_string) - 1)) { | |
d550d98d | 484 | return -EINVAL; |
1da177e4 LT |
485 | } |
486 | ||
487 | if (copy_from_user(limit_string, buffer, count)) { | |
d550d98d | 488 | return -EFAULT; |
1da177e4 LT |
489 | } |
490 | ||
491 | limit_string[count] = '\0'; | |
492 | ||
493 | if (sscanf(limit_string, "%d:%d", &px, &tx) != 2) { | |
6468463a | 494 | printk(KERN_ERR PREFIX "Invalid data format\n"); |
d550d98d | 495 | return -EINVAL; |
1da177e4 LT |
496 | } |
497 | ||
498 | if (pr->flags.throttling) { | |
499 | if ((tx < 0) || (tx > (pr->throttling.state_count - 1))) { | |
6468463a | 500 | printk(KERN_ERR PREFIX "Invalid tx\n"); |
d550d98d | 501 | return -EINVAL; |
1da177e4 LT |
502 | } |
503 | pr->limit.user.tx = tx; | |
504 | } | |
505 | ||
506 | result = acpi_processor_apply_limit(pr); | |
507 | ||
d550d98d | 508 | return count; |
1da177e4 LT |
509 | } |
510 | ||
1da177e4 | 511 | struct file_operations acpi_processor_limit_fops = { |
cf7acfab | 512 | .owner = THIS_MODULE, |
4be44fcd LB |
513 | .open = acpi_processor_limit_open_fs, |
514 | .read = seq_read, | |
d479e908 | 515 | .write = acpi_processor_write_limit, |
4be44fcd LB |
516 | .llseek = seq_lseek, |
517 | .release = single_release, | |
1da177e4 | 518 | }; |