2 * Windfarm PowerMac thermal control. SMU based 1 CPU desktop control loops
4 * (c) Copyright 2005 Benjamin Herrenschmidt, IBM Corp.
5 * <benh@kernel.crashing.org>
7 * Released under the term of the GNU GPL v2.
9 * The algorithm used is the PID control algorithm, used the same
10 * way the published Darwin code does, using the same values that
11 * are present in the Darwin 8.2 snapshot property lists (note however
12 * that none of the code has been re-used, it's a complete re-implementation
14 * The various control loops found in Darwin config file are:
19 * Has 3 control loops: CPU fans is similar to PowerMac8,1 (though it doesn't
20 * try to play with other control loops fans). Drive bay is rather basic PID
21 * with one sensor and one fan. Slots area is a bit different as the Darwin
22 * driver is supposed to be capable of working in a special "AGP" mode which
23 * involves the presence of an AGP sensor and an AGP fan (possibly on the
24 * AGP card itself). I can't deal with that special mode as I don't have
25 * access to those additional sensor/fans for now (though ultimately, it would
26 * be possible to add sensor objects for them) so I'm only implementing the
27 * basic PCI slot control loop
30 #include <linux/types.h>
31 #include <linux/errno.h>
32 #include <linux/kernel.h>
33 #include <linux/delay.h>
34 #include <linux/slab.h>
35 #include <linux/init.h>
36 #include <linux/spinlock.h>
37 #include <linux/wait.h>
38 #include <linux/kmod.h>
39 #include <linux/device.h>
40 #include <linux/platform_device.h>
42 #include <asm/machdep.h>
44 #include <asm/sections.h>
48 #include "windfarm_pid.h"
55 #define DBG(args...) printk(args)
57 #define DBG(args...) do { } while(0)
60 /* define this to force CPU overtemp to 74 degree, useful for testing
63 #undef HACKED_OVERTEMP
65 /* Controls & sensors */
66 static struct wf_sensor
*sensor_cpu_power
;
67 static struct wf_sensor
*sensor_cpu_temp
;
68 static struct wf_sensor
*sensor_hd_temp
;
69 static struct wf_sensor
*sensor_slots_power
;
70 static struct wf_control
*fan_cpu_main
;
71 static struct wf_control
*fan_cpu_second
;
72 static struct wf_control
*fan_cpu_third
;
73 static struct wf_control
*fan_hd
;
74 static struct wf_control
*fan_slots
;
75 static struct wf_control
*cpufreq_clamp
;
77 /* Set to kick the control loop into life */
78 static int wf_smu_all_controls_ok
, wf_smu_all_sensors_ok
, wf_smu_started
;
80 /* Failure handling.. could be nicer */
81 #define FAILURE_FAN 0x01
82 #define FAILURE_SENSOR 0x02
83 #define FAILURE_OVERTEMP 0x04
85 static unsigned int wf_smu_failure_state
;
86 static int wf_smu_readjust
, wf_smu_skipping
;
89 * ****** CPU Fans Control Loop ******
94 #define WF_SMU_CPU_FANS_INTERVAL 1
95 #define WF_SMU_CPU_FANS_MAX_HISTORY 16
97 /* State data used by the cpu fans control loop
99 struct wf_smu_cpu_fans_state
{
102 struct wf_cpu_pid_state pid
;
105 static struct wf_smu_cpu_fans_state
*wf_smu_cpu_fans
;
110 * ****** Drive Fan Control Loop ******
114 struct wf_smu_drive_fans_state
{
117 struct wf_pid_state pid
;
120 static struct wf_smu_drive_fans_state
*wf_smu_drive_fans
;
123 * ****** Slots Fan Control Loop ******
127 struct wf_smu_slots_fans_state
{
130 struct wf_pid_state pid
;
133 static struct wf_smu_slots_fans_state
*wf_smu_slots_fans
;
136 * ***** Implementation *****
141 static void wf_smu_create_cpu_fans(void)
143 struct wf_cpu_pid_param pid_param
;
144 const struct smu_sdbp_header
*hdr
;
145 struct smu_sdbp_cpupiddata
*piddata
;
146 struct smu_sdbp_fvt
*fvt
;
147 s32 tmax
, tdelta
, maxpow
, powadj
;
149 /* First, locate the PID params in SMU SBD */
150 hdr
= smu_get_sdb_partition(SMU_SDB_CPUPIDDATA_ID
, NULL
);
152 printk(KERN_WARNING
"windfarm: CPU PID fan config not found "
156 piddata
= (struct smu_sdbp_cpupiddata
*)&hdr
[1];
158 /* Get the FVT params for operating point 0 (the only supported one
159 * for now) in order to get tmax
161 hdr
= smu_get_sdb_partition(SMU_SDB_FVT_ID
, NULL
);
163 fvt
= (struct smu_sdbp_fvt
*)&hdr
[1];
164 tmax
= ((s32
)fvt
->maxtemp
) << 16;
166 tmax
= 0x5e0000; /* 94 degree default */
168 /* Alloc & initialize state */
169 wf_smu_cpu_fans
= kmalloc(sizeof(struct wf_smu_cpu_fans_state
),
171 if (wf_smu_cpu_fans
== NULL
)
173 wf_smu_cpu_fans
->ticks
= 1;
175 /* Fill PID params */
176 pid_param
.interval
= WF_SMU_CPU_FANS_INTERVAL
;
177 pid_param
.history_len
= piddata
->history_len
;
178 if (pid_param
.history_len
> WF_CPU_PID_MAX_HISTORY
) {
179 printk(KERN_WARNING
"windfarm: History size overflow on "
180 "CPU control loop (%d)\n", piddata
->history_len
);
181 pid_param
.history_len
= WF_CPU_PID_MAX_HISTORY
;
183 pid_param
.gd
= piddata
->gd
;
184 pid_param
.gp
= piddata
->gp
;
185 pid_param
.gr
= piddata
->gr
/ pid_param
.history_len
;
187 tdelta
= ((s32
)piddata
->target_temp_delta
) << 16;
188 maxpow
= ((s32
)piddata
->max_power
) << 16;
189 powadj
= ((s32
)piddata
->power_adj
) << 16;
191 pid_param
.tmax
= tmax
;
192 pid_param
.ttarget
= tmax
- tdelta
;
193 pid_param
.pmaxadj
= maxpow
- powadj
;
195 pid_param
.min
= fan_cpu_main
->ops
->get_min(fan_cpu_main
);
196 pid_param
.max
= fan_cpu_main
->ops
->get_max(fan_cpu_main
);
198 wf_cpu_pid_init(&wf_smu_cpu_fans
->pid
, &pid_param
);
200 DBG("wf: CPU Fan control initialized.\n");
201 DBG(" ttarged=%d.%03d, tmax=%d.%03d, min=%d RPM, max=%d RPM\n",
202 FIX32TOPRINT(pid_param
.ttarget
), FIX32TOPRINT(pid_param
.tmax
),
203 pid_param
.min
, pid_param
.max
);
208 printk(KERN_WARNING
"windfarm: CPU fan config not found\n"
209 "for this machine model, max fan speed\n");
212 wf_control_set_max(cpufreq_clamp
);
214 wf_control_set_max(fan_cpu_main
);
217 static void wf_smu_cpu_fans_tick(struct wf_smu_cpu_fans_state
*st
)
219 s32 new_setpoint
, temp
, power
;
222 if (--st
->ticks
!= 0) {
227 st
->ticks
= WF_SMU_CPU_FANS_INTERVAL
;
229 rc
= sensor_cpu_temp
->ops
->get_value(sensor_cpu_temp
, &temp
);
231 printk(KERN_WARNING
"windfarm: CPU temp sensor error %d\n",
233 wf_smu_failure_state
|= FAILURE_SENSOR
;
237 rc
= sensor_cpu_power
->ops
->get_value(sensor_cpu_power
, &power
);
239 printk(KERN_WARNING
"windfarm: CPU power sensor error %d\n",
241 wf_smu_failure_state
|= FAILURE_SENSOR
;
245 DBG("wf_smu: CPU Fans tick ! CPU temp: %d.%03d, power: %d.%03d\n",
246 FIX32TOPRINT(temp
), FIX32TOPRINT(power
));
248 #ifdef HACKED_OVERTEMP
250 wf_smu_failure_state
|= FAILURE_OVERTEMP
;
252 if (temp
> st
->pid
.param
.tmax
)
253 wf_smu_failure_state
|= FAILURE_OVERTEMP
;
255 new_setpoint
= wf_cpu_pid_run(&st
->pid
, power
, temp
);
257 DBG("wf_smu: new_setpoint: %d RPM\n", (int)new_setpoint
);
259 if (st
->cpu_setpoint
== new_setpoint
)
261 st
->cpu_setpoint
= new_setpoint
;
263 if (fan_cpu_main
&& wf_smu_failure_state
== 0) {
264 rc
= fan_cpu_main
->ops
->set_value(fan_cpu_main
,
267 printk(KERN_WARNING
"windfarm: CPU main fan"
269 wf_smu_failure_state
|= FAILURE_FAN
;
272 if (fan_cpu_second
&& wf_smu_failure_state
== 0) {
273 rc
= fan_cpu_second
->ops
->set_value(fan_cpu_second
,
276 printk(KERN_WARNING
"windfarm: CPU second fan"
278 wf_smu_failure_state
|= FAILURE_FAN
;
281 if (fan_cpu_third
&& wf_smu_failure_state
== 0) {
282 rc
= fan_cpu_main
->ops
->set_value(fan_cpu_third
,
285 printk(KERN_WARNING
"windfarm: CPU third fan"
287 wf_smu_failure_state
|= FAILURE_FAN
;
292 static void wf_smu_create_drive_fans(void)
294 struct wf_pid_param param
= {
300 .itarget
= 0x00200000,
303 /* Alloc & initialize state */
304 wf_smu_drive_fans
= kmalloc(sizeof(struct wf_smu_drive_fans_state
),
306 if (wf_smu_drive_fans
== NULL
) {
307 printk(KERN_WARNING
"windfarm: Memory allocation error"
311 wf_smu_drive_fans
->ticks
= 1;
313 /* Fill PID params */
314 param
.additive
= (fan_hd
->type
== WF_CONTROL_RPM_FAN
);
315 param
.min
= fan_hd
->ops
->get_min(fan_hd
);
316 param
.max
= fan_hd
->ops
->get_max(fan_hd
);
317 wf_pid_init(&wf_smu_drive_fans
->pid
, ¶m
);
319 DBG("wf: Drive Fan control initialized.\n");
320 DBG(" itarged=%d.%03d, min=%d RPM, max=%d RPM\n",
321 FIX32TOPRINT(param
.itarget
), param
.min
, param
.max
);
326 wf_control_set_max(fan_hd
);
329 static void wf_smu_drive_fans_tick(struct wf_smu_drive_fans_state
*st
)
331 s32 new_setpoint
, temp
;
334 if (--st
->ticks
!= 0) {
339 st
->ticks
= st
->pid
.param
.interval
;
341 rc
= sensor_hd_temp
->ops
->get_value(sensor_hd_temp
, &temp
);
343 printk(KERN_WARNING
"windfarm: HD temp sensor error %d\n",
345 wf_smu_failure_state
|= FAILURE_SENSOR
;
349 DBG("wf_smu: Drive Fans tick ! HD temp: %d.%03d\n",
352 if (temp
> (st
->pid
.param
.itarget
+ 0x50000))
353 wf_smu_failure_state
|= FAILURE_OVERTEMP
;
355 new_setpoint
= wf_pid_run(&st
->pid
, temp
);
357 DBG("wf_smu: new_setpoint: %d\n", (int)new_setpoint
);
359 if (st
->setpoint
== new_setpoint
)
361 st
->setpoint
= new_setpoint
;
363 if (fan_hd
&& wf_smu_failure_state
== 0) {
364 rc
= fan_hd
->ops
->set_value(fan_hd
, st
->setpoint
);
366 printk(KERN_WARNING
"windfarm: HD fan error %d\n",
368 wf_smu_failure_state
|= FAILURE_FAN
;
373 static void wf_smu_create_slots_fans(void)
375 struct wf_pid_param param
= {
381 .itarget
= 0x00000000
384 /* Alloc & initialize state */
385 wf_smu_slots_fans
= kmalloc(sizeof(struct wf_smu_slots_fans_state
),
387 if (wf_smu_slots_fans
== NULL
) {
388 printk(KERN_WARNING
"windfarm: Memory allocation error"
392 wf_smu_slots_fans
->ticks
= 1;
394 /* Fill PID params */
395 param
.additive
= (fan_slots
->type
== WF_CONTROL_RPM_FAN
);
396 param
.min
= fan_slots
->ops
->get_min(fan_slots
);
397 param
.max
= fan_slots
->ops
->get_max(fan_slots
);
398 wf_pid_init(&wf_smu_slots_fans
->pid
, ¶m
);
400 DBG("wf: Slots Fan control initialized.\n");
401 DBG(" itarged=%d.%03d, min=%d RPM, max=%d RPM\n",
402 FIX32TOPRINT(param
.itarget
), param
.min
, param
.max
);
407 wf_control_set_max(fan_slots
);
410 static void wf_smu_slots_fans_tick(struct wf_smu_slots_fans_state
*st
)
412 s32 new_setpoint
, power
;
415 if (--st
->ticks
!= 0) {
420 st
->ticks
= st
->pid
.param
.interval
;
422 rc
= sensor_slots_power
->ops
->get_value(sensor_slots_power
, &power
);
424 printk(KERN_WARNING
"windfarm: Slots power sensor error %d\n",
426 wf_smu_failure_state
|= FAILURE_SENSOR
;
430 DBG("wf_smu: Slots Fans tick ! Slots power: %d.%03d\n",
431 FIX32TOPRINT(power
));
433 #if 0 /* Check what makes a good overtemp condition */
434 if (power
> (st
->pid
.param
.itarget
+ 0x50000))
435 wf_smu_failure_state
|= FAILURE_OVERTEMP
;
438 new_setpoint
= wf_pid_run(&st
->pid
, power
);
440 DBG("wf_smu: new_setpoint: %d\n", (int)new_setpoint
);
442 if (st
->setpoint
== new_setpoint
)
444 st
->setpoint
= new_setpoint
;
446 if (fan_slots
&& wf_smu_failure_state
== 0) {
447 rc
= fan_slots
->ops
->set_value(fan_slots
, st
->setpoint
);
449 printk(KERN_WARNING
"windfarm: Slots fan error %d\n",
451 wf_smu_failure_state
|= FAILURE_FAN
;
458 * ****** Setup / Init / Misc ... ******
462 static void wf_smu_tick(void)
464 unsigned int last_failure
= wf_smu_failure_state
;
465 unsigned int new_failure
;
467 if (!wf_smu_started
) {
468 DBG("wf: creating control loops !\n");
469 wf_smu_create_drive_fans();
470 wf_smu_create_slots_fans();
471 wf_smu_create_cpu_fans();
476 if (wf_smu_skipping
&& --wf_smu_skipping
)
479 wf_smu_failure_state
= 0;
480 if (wf_smu_drive_fans
)
481 wf_smu_drive_fans_tick(wf_smu_drive_fans
);
482 if (wf_smu_slots_fans
)
483 wf_smu_slots_fans_tick(wf_smu_slots_fans
);
485 wf_smu_cpu_fans_tick(wf_smu_cpu_fans
);
488 new_failure
= wf_smu_failure_state
& ~last_failure
;
490 /* If entering failure mode, clamp cpufreq and ramp all
491 * fans to full speed.
493 if (wf_smu_failure_state
&& !last_failure
) {
495 wf_control_set_max(cpufreq_clamp
);
497 wf_control_set_max(fan_cpu_main
);
499 wf_control_set_max(fan_cpu_second
);
501 wf_control_set_max(fan_cpu_third
);
503 wf_control_set_max(fan_hd
);
505 wf_control_set_max(fan_slots
);
508 /* If leaving failure mode, unclamp cpufreq and readjust
509 * all fans on next iteration
511 if (!wf_smu_failure_state
&& last_failure
) {
513 wf_control_set_min(cpufreq_clamp
);
517 /* Overtemp condition detected, notify and start skipping a couple
518 * ticks to let the temperature go down
520 if (new_failure
& FAILURE_OVERTEMP
) {
525 /* We only clear the overtemp condition if overtemp is cleared
526 * _and_ no other failure is present. Since a sensor error will
527 * clear the overtemp condition (can't measure temperature) at
528 * the control loop levels, but we don't want to keep it clear
531 if (new_failure
== 0 && last_failure
& FAILURE_OVERTEMP
)
536 static void wf_smu_new_control(struct wf_control
*ct
)
538 if (wf_smu_all_controls_ok
)
541 if (fan_cpu_main
== NULL
&& !strcmp(ct
->name
, "cpu-rear-fan-0")) {
542 if (wf_get_control(ct
) == 0)
546 if (fan_cpu_second
== NULL
&& !strcmp(ct
->name
, "cpu-rear-fan-1")) {
547 if (wf_get_control(ct
) == 0)
551 if (fan_cpu_third
== NULL
&& !strcmp(ct
->name
, "cpu-front-fan-0")) {
552 if (wf_get_control(ct
) == 0)
556 if (cpufreq_clamp
== NULL
&& !strcmp(ct
->name
, "cpufreq-clamp")) {
557 if (wf_get_control(ct
) == 0)
561 if (fan_hd
== NULL
&& !strcmp(ct
->name
, "drive-bay-fan")) {
562 if (wf_get_control(ct
) == 0)
566 if (fan_slots
== NULL
&& !strcmp(ct
->name
, "slots-fan")) {
567 if (wf_get_control(ct
) == 0)
571 if (fan_cpu_main
&& (fan_cpu_second
|| fan_cpu_third
) && fan_hd
&&
572 fan_slots
&& cpufreq_clamp
)
573 wf_smu_all_controls_ok
= 1;
576 static void wf_smu_new_sensor(struct wf_sensor
*sr
)
578 if (wf_smu_all_sensors_ok
)
581 if (sensor_cpu_power
== NULL
&& !strcmp(sr
->name
, "cpu-power")) {
582 if (wf_get_sensor(sr
) == 0)
583 sensor_cpu_power
= sr
;
586 if (sensor_cpu_temp
== NULL
&& !strcmp(sr
->name
, "cpu-temp")) {
587 if (wf_get_sensor(sr
) == 0)
588 sensor_cpu_temp
= sr
;
591 if (sensor_hd_temp
== NULL
&& !strcmp(sr
->name
, "hd-temp")) {
592 if (wf_get_sensor(sr
) == 0)
596 if (sensor_slots_power
== NULL
&& !strcmp(sr
->name
, "slots-power")) {
597 if (wf_get_sensor(sr
) == 0)
598 sensor_slots_power
= sr
;
601 if (sensor_cpu_power
&& sensor_cpu_temp
&&
602 sensor_hd_temp
&& sensor_slots_power
)
603 wf_smu_all_sensors_ok
= 1;
607 static int wf_smu_notify(struct notifier_block
*self
,
608 unsigned long event
, void *data
)
611 case WF_EVENT_NEW_CONTROL
:
612 DBG("wf: new control %s detected\n",
613 ((struct wf_control
*)data
)->name
);
614 wf_smu_new_control(data
);
617 case WF_EVENT_NEW_SENSOR
:
618 DBG("wf: new sensor %s detected\n",
619 ((struct wf_sensor
*)data
)->name
);
620 wf_smu_new_sensor(data
);
623 if (wf_smu_all_controls_ok
&& wf_smu_all_sensors_ok
)
630 static struct notifier_block wf_smu_events
= {
631 .notifier_call
= wf_smu_notify
,
634 static int wf_init_pm(void)
636 printk(KERN_INFO
"windfarm: Initializing for Desktop G5 model\n");
641 static int wf_smu_probe(struct platform_device
*ddev
)
643 wf_register_client(&wf_smu_events
);
648 static int __devexit
wf_smu_remove(struct platform_device
*ddev
)
650 wf_unregister_client(&wf_smu_events
);
652 /* XXX We don't have yet a guarantee that our callback isn't
653 * in progress when returning from wf_unregister_client, so
654 * we add an arbitrary delay. I'll have to fix that in the core
658 /* Release all sensors */
659 /* One more crappy race: I don't think we have any guarantee here
660 * that the attribute callback won't race with the sensor beeing
661 * disposed of, and I'm not 100% certain what best way to deal
662 * with that except by adding locks all over... I'll do that
663 * eventually but heh, who ever rmmod this module anyway ?
665 if (sensor_cpu_power
)
666 wf_put_sensor(sensor_cpu_power
);
668 wf_put_sensor(sensor_cpu_temp
);
670 wf_put_sensor(sensor_hd_temp
);
671 if (sensor_slots_power
)
672 wf_put_sensor(sensor_slots_power
);
674 /* Release all controls */
676 wf_put_control(fan_cpu_main
);
678 wf_put_control(fan_cpu_second
);
680 wf_put_control(fan_cpu_third
);
682 wf_put_control(fan_hd
);
684 wf_put_control(fan_slots
);
686 wf_put_control(cpufreq_clamp
);
688 /* Destroy control loops state structures */
689 kfree(wf_smu_slots_fans
);
690 kfree(wf_smu_drive_fans
);
691 kfree(wf_smu_cpu_fans
);
696 static struct platform_driver wf_smu_driver
= {
697 .probe
= wf_smu_probe
,
698 .remove
= __devexit_p(wf_smu_remove
),
701 .owner
= THIS_MODULE
,
706 static int __init
wf_smu_init(void)
710 if (of_machine_is_compatible("PowerMac9,1"))
715 request_module("windfarm_smu_controls");
716 request_module("windfarm_smu_sensors");
717 request_module("windfarm_lm75_sensor");
718 request_module("windfarm_cpufreq_clamp");
721 platform_driver_register(&wf_smu_driver
);
727 static void __exit
wf_smu_exit(void)
730 platform_driver_unregister(&wf_smu_driver
);
734 module_init(wf_smu_init
);
735 module_exit(wf_smu_exit
);
737 MODULE_AUTHOR("Benjamin Herrenschmidt <benh@kernel.crashing.org>");
738 MODULE_DESCRIPTION("Thermal control logic for PowerMac9,1");
739 MODULE_LICENSE("GPL");
741 MODULE_ALIAS("platform:windfarm");