2 * Device driver for the thermostats & fan controller of the
3 * Apple G5 "PowerMac7,2" desktop machines.
5 * (c) Copyright IBM Corp. 2003-2004
7 * Maintained by: Benjamin Herrenschmidt
8 * <benh@kernel.crashing.org>
11 * The algorithm used is the PID control algorithm, used the same
12 * way the published Darwin code does, using the same values that
13 * are present in the Darwin 7.0 snapshot property lists.
15 * As far as the CPUs control loops are concerned, I use the
16 * calibration & PID constants provided by the EEPROM,
17 * I do _not_ embed any value from the property lists, as the ones
18 * provided by Darwin 7.0 seem to always have an older version that
19 * what I've seen on the actual computers.
20 * It would be interesting to verify that though. Darwin has a
21 * version code of 1.0.0d11 for all control loops it seems, while
22 * so far, the machines EEPROMs contain a dataset versioned 1.0.0f
24 * Darwin doesn't provide source to all parts, some missing
25 * bits like the AppleFCU driver or the actual scale of some
26 * of the values returned by sensors had to be "guessed" some
27 * way... or based on what Open Firmware does.
29 * I didn't yet figure out how to get the slots power consumption
30 * out of the FCU, so that part has not been implemented yet and
31 * the slots fan is set to a fixed 50% PWM, hoping this value is
34 * Note: I have observed strange oscillations of the CPU control
35 * loop on a dual G5 here. When idle, the CPU exhaust fan tend to
36 * oscillates slowly (over several minutes) between the minimum
37 * of 300RPMs and approx. 1000 RPMs. I don't know what is causing
38 * this, it could be some incorrect constant or an error in the
39 * way I ported the algorithm, or it could be just normal. I
40 * don't have full understanding on the way Apple tweaked the PID
41 * algorithm for the CPU control, it is definitely not a standard
44 * TODO: - Check MPU structure version/signature
45 * - Add things like /sbin/overtemp for non-critical
46 * overtemp conditions so userland can take some policy
47 * decisions, like slewing down CPUs
48 * - Deal with fan and i2c failures in a better way
49 * - Maybe do a generic PID based on params used for
50 * U3 and Drives ? Definitely need to factor code a bit
51 * bettter... also make sensor detection more robust using
52 * the device-tree to probe for them
53 * - Figure out how to get the slots consumption and set the
54 * slots fan accordingly
62 * - Read fan speed from FCU, low level fan routines now deal
63 * with errors & check fan status, though higher level don't
65 * - Move a bunch of definitions to .h file
68 * - Fix build on ppc64 kernel
69 * - Move back statics definitions to .c file
70 * - Avoid calling schedule_timeout with a negative number
73 * - Fix typo when reading back fan speed on 2 CPU machines
76 * - Rework code accessing the ADC chips, make it more robust and
77 * closer to the chip spec. Also make sure it is configured properly,
78 * I've seen yet unexplained cases where on startup, I would have stale
79 * values in the configuration register
80 * - Switch back to use of target fan speed for PID, thus lowering
84 * - Add device-tree lookup for fan IDs, should detect liquid cooling
86 * - Enable driver for PowerMac7,3 machines
87 * - Split the U3/Backside cooling on U3 & U3H versions as Darwin does
88 * - Add new CPU cooling algorithm for machines with liquid cooling
89 * - Workaround for some PowerMac7,3 with empty "fan" node in the devtree
90 * - Fix a signed/unsigned compare issue in some PID loops
93 * - Add basic support for Xserve G5
94 * - Retreive pumps min/max from EEPROM image in device-tree (broken)
95 * - Use min/max macros here or there
96 * - Latest darwin updated U3H min fan speed to 20% PWM
100 #include <linux/types.h>
101 #include <linux/module.h>
102 #include <linux/errno.h>
103 #include <linux/kernel.h>
104 #include <linux/delay.h>
105 #include <linux/sched.h>
106 #include <linux/slab.h>
107 #include <linux/init.h>
108 #include <linux/spinlock.h>
109 #include <linux/smp_lock.h>
110 #include <linux/wait.h>
111 #include <linux/reboot.h>
112 #include <linux/kmod.h>
113 #include <linux/i2c.h>
114 #include <asm/prom.h>
115 #include <asm/machdep.h>
117 #include <asm/system.h>
118 #include <asm/sections.h>
119 #include <asm/of_device.h>
120 #include <asm/macio.h>
122 #include "therm_pm72.h"
124 #define VERSION "1.2b2"
129 #define DBG(args...) printk(args)
131 #define DBG(args...) do { } while(0)
139 static struct of_device
* of_dev
;
140 static struct i2c_adapter
* u3_0
;
141 static struct i2c_adapter
* u3_1
;
142 static struct i2c_adapter
* k2
;
143 static struct i2c_client
* fcu
;
144 static struct cpu_pid_state cpu_state
[2];
145 static struct basckside_pid_params backside_params
;
146 static struct backside_pid_state backside_state
;
147 static struct drives_pid_state drives_state
;
148 static struct dimm_pid_state dimms_state
;
150 static int cpu_count
;
151 static int cpu_pid_type
;
152 static pid_t ctrl_task
;
153 static struct completion ctrl_complete
;
154 static int critical_state
;
156 static s32 dimm_output_clamp
;
158 static DECLARE_MUTEX(driver_lock
);
161 * We have 3 types of CPU PID control. One is "split" old style control
162 * for intake & exhaust fans, the other is "combined" control for both
163 * CPUs that also deals with the pumps when present. To be "compatible"
164 * with OS X at this point, we only use "COMBINED" on the machines that
165 * are identified as having the pumps (though that identification is at
166 * least dodgy). Ultimately, we could probably switch completely to this
167 * algorithm provided we hack it to deal with the UP case
169 #define CPU_PID_TYPE_SPLIT 0
170 #define CPU_PID_TYPE_COMBINED 1
171 #define CPU_PID_TYPE_RACKMAC 2
174 * This table describes all fans in the FCU. The "id" and "type" values
175 * are defaults valid for all earlier machines. Newer machines will
176 * eventually override the table content based on the device-tree
180 char* loc
; /* location code */
181 int type
; /* 0 = rpm, 1 = pwm, 2 = pump */
182 int id
; /* id or -1 */
185 #define FCU_FAN_RPM 0
186 #define FCU_FAN_PWM 1
188 #define FCU_FAN_ABSENT_ID -1
190 #define FCU_FAN_COUNT ARRAY_SIZE(fcu_fans)
192 struct fcu_fan_table fcu_fans
[] = {
193 [BACKSIDE_FAN_PWM_INDEX
] = {
194 .loc
= "BACKSIDE,SYS CTRLR FAN",
196 .id
= BACKSIDE_FAN_PWM_DEFAULT_ID
,
198 [DRIVES_FAN_RPM_INDEX
] = {
201 .id
= DRIVES_FAN_RPM_DEFAULT_ID
,
203 [SLOTS_FAN_PWM_INDEX
] = {
204 .loc
= "SLOT,PCI FAN",
206 .id
= SLOTS_FAN_PWM_DEFAULT_ID
,
208 [CPUA_INTAKE_FAN_RPM_INDEX
] = {
209 .loc
= "CPU A INTAKE",
211 .id
= CPUA_INTAKE_FAN_RPM_DEFAULT_ID
,
213 [CPUA_EXHAUST_FAN_RPM_INDEX
] = {
214 .loc
= "CPU A EXHAUST",
216 .id
= CPUA_EXHAUST_FAN_RPM_DEFAULT_ID
,
218 [CPUB_INTAKE_FAN_RPM_INDEX
] = {
219 .loc
= "CPU B INTAKE",
221 .id
= CPUB_INTAKE_FAN_RPM_DEFAULT_ID
,
223 [CPUB_EXHAUST_FAN_RPM_INDEX
] = {
224 .loc
= "CPU B EXHAUST",
226 .id
= CPUB_EXHAUST_FAN_RPM_DEFAULT_ID
,
228 /* pumps aren't present by default, have to be looked up in the
231 [CPUA_PUMP_RPM_INDEX
] = {
234 .id
= FCU_FAN_ABSENT_ID
,
236 [CPUB_PUMP_RPM_INDEX
] = {
239 .id
= FCU_FAN_ABSENT_ID
,
242 [CPU_A1_FAN_RPM_INDEX
] = {
245 .id
= FCU_FAN_ABSENT_ID
,
247 [CPU_A2_FAN_RPM_INDEX
] = {
250 .id
= FCU_FAN_ABSENT_ID
,
252 [CPU_A3_FAN_RPM_INDEX
] = {
255 .id
= FCU_FAN_ABSENT_ID
,
257 [CPU_B1_FAN_RPM_INDEX
] = {
260 .id
= FCU_FAN_ABSENT_ID
,
262 [CPU_B2_FAN_RPM_INDEX
] = {
265 .id
= FCU_FAN_ABSENT_ID
,
267 [CPU_B3_FAN_RPM_INDEX
] = {
270 .id
= FCU_FAN_ABSENT_ID
,
275 * i2c_driver structure to attach to the host i2c controller
278 static int therm_pm72_attach(struct i2c_adapter
*adapter
);
279 static int therm_pm72_detach(struct i2c_adapter
*adapter
);
281 static struct i2c_driver therm_pm72_driver
=
284 .name
= "therm_pm72",
286 .attach_adapter
= therm_pm72_attach
,
287 .detach_adapter
= therm_pm72_detach
,
291 * Utility function to create an i2c_client structure and
292 * attach it to one of u3 adapters
294 static struct i2c_client
*attach_i2c_chip(int id
, const char *name
)
296 struct i2c_client
*clt
;
297 struct i2c_adapter
*adap
;
308 clt
= kmalloc(sizeof(struct i2c_client
), GFP_KERNEL
);
311 memset(clt
, 0, sizeof(struct i2c_client
));
313 clt
->addr
= (id
>> 1) & 0x7f;
315 clt
->driver
= &therm_pm72_driver
;
316 strncpy(clt
->name
, name
, I2C_NAME_SIZE
-1);
318 if (i2c_attach_client(clt
)) {
319 printk(KERN_ERR
"therm_pm72: Failed to attach to i2c ID 0x%x\n", id
);
327 * Utility function to get rid of the i2c_client structure
328 * (will also detach from the adapter hopepfully)
330 static void detach_i2c_chip(struct i2c_client
*clt
)
332 i2c_detach_client(clt
);
337 * Here are the i2c chip access wrappers
340 static void initialize_adc(struct cpu_pid_state
*state
)
345 /* Read ADC the configuration register and cache it. We
346 * also make sure Config2 contains proper values, I've seen
347 * cases where we got stale grabage in there, thus preventing
348 * proper reading of conv. values
354 i2c_master_send(state
->monitor
, buf
, 2);
356 /* Read & cache Config1 */
358 rc
= i2c_master_send(state
->monitor
, buf
, 1);
360 rc
= i2c_master_recv(state
->monitor
, buf
, 1);
362 state
->adc_config
= buf
[0];
363 DBG("ADC config reg: %02x\n", state
->adc_config
);
364 /* Disable shutdown mode */
365 state
->adc_config
&= 0xfe;
367 buf
[1] = state
->adc_config
;
368 rc
= i2c_master_send(state
->monitor
, buf
, 2);
372 printk(KERN_ERR
"therm_pm72: Error reading ADC config"
376 static int read_smon_adc(struct cpu_pid_state
*state
, int chan
)
378 int rc
, data
, tries
= 0;
384 buf
[1] = (state
->adc_config
& 0x1f) | (chan
<< 5);
385 rc
= i2c_master_send(state
->monitor
, buf
, 2);
388 /* Wait for convertion */
390 /* Switch to data register */
392 rc
= i2c_master_send(state
->monitor
, buf
, 1);
396 rc
= i2c_master_recv(state
->monitor
, buf
, 2);
399 data
= ((u16
)buf
[0]) << 8 | (u16
)buf
[1];
402 DBG("Error reading ADC, retrying...\n");
404 printk(KERN_ERR
"therm_pm72: Error reading ADC !\n");
411 static int read_lm87_reg(struct i2c_client
* chip
, int reg
)
419 rc
= i2c_master_send(chip
, &buf
, 1);
422 rc
= i2c_master_recv(chip
, &buf
, 1);
427 DBG("Error reading LM87, retrying...\n");
429 printk(KERN_ERR
"therm_pm72: Error reading LM87 !\n");
436 static int fan_read_reg(int reg
, unsigned char *buf
, int nb
)
443 nw
= i2c_master_send(fcu
, buf
, 1);
444 if (nw
> 0 || (nw
< 0 && nw
!= -EIO
) || tries
>= 100)
450 printk(KERN_ERR
"Failure writing address to FCU: %d", nw
);
455 nr
= i2c_master_recv(fcu
, buf
, nb
);
456 if (nr
> 0 || (nr
< 0 && nr
!= ENODEV
) || tries
>= 100)
462 printk(KERN_ERR
"Failure reading data from FCU: %d", nw
);
466 static int fan_write_reg(int reg
, const unsigned char *ptr
, int nb
)
469 unsigned char buf
[16];
472 memcpy(buf
+1, ptr
, nb
);
476 nw
= i2c_master_send(fcu
, buf
, nb
);
477 if (nw
> 0 || (nw
< 0 && nw
!= EIO
) || tries
>= 100)
483 printk(KERN_ERR
"Failure writing to FCU: %d", nw
);
487 static int start_fcu(void)
489 unsigned char buf
= 0xff;
492 rc
= fan_write_reg(0xe, &buf
, 1);
495 rc
= fan_write_reg(0x2e, &buf
, 1);
501 static int set_rpm_fan(int fan_index
, int rpm
)
503 unsigned char buf
[2];
506 if (fcu_fans
[fan_index
].type
!= FCU_FAN_RPM
)
508 id
= fcu_fans
[fan_index
].id
;
509 if (id
== FCU_FAN_ABSENT_ID
)
518 rc
= fan_write_reg(0x10 + (id
* 2), buf
, 2);
524 static int get_rpm_fan(int fan_index
, int programmed
)
526 unsigned char failure
;
527 unsigned char active
;
528 unsigned char buf
[2];
529 int rc
, id
, reg_base
;
531 if (fcu_fans
[fan_index
].type
!= FCU_FAN_RPM
)
533 id
= fcu_fans
[fan_index
].id
;
534 if (id
== FCU_FAN_ABSENT_ID
)
537 rc
= fan_read_reg(0xb, &failure
, 1);
540 if ((failure
& (1 << id
)) != 0)
542 rc
= fan_read_reg(0xd, &active
, 1);
545 if ((active
& (1 << id
)) == 0)
548 /* Programmed value or real current speed */
549 reg_base
= programmed
? 0x10 : 0x11;
550 rc
= fan_read_reg(reg_base
+ (id
* 2), buf
, 2);
554 return (buf
[0] << 5) | buf
[1] >> 3;
557 static int set_pwm_fan(int fan_index
, int pwm
)
559 unsigned char buf
[2];
562 if (fcu_fans
[fan_index
].type
!= FCU_FAN_PWM
)
564 id
= fcu_fans
[fan_index
].id
;
565 if (id
== FCU_FAN_ABSENT_ID
)
572 pwm
= (pwm
* 2559) / 1000;
574 rc
= fan_write_reg(0x30 + (id
* 2), buf
, 1);
580 static int get_pwm_fan(int fan_index
)
582 unsigned char failure
;
583 unsigned char active
;
584 unsigned char buf
[2];
587 if (fcu_fans
[fan_index
].type
!= FCU_FAN_PWM
)
589 id
= fcu_fans
[fan_index
].id
;
590 if (id
== FCU_FAN_ABSENT_ID
)
593 rc
= fan_read_reg(0x2b, &failure
, 1);
596 if ((failure
& (1 << id
)) != 0)
598 rc
= fan_read_reg(0x2d, &active
, 1);
601 if ((active
& (1 << id
)) == 0)
604 /* Programmed value or real current speed */
605 rc
= fan_read_reg(0x30 + (id
* 2), buf
, 1);
609 return (buf
[0] * 1000) / 2559;
613 * Utility routine to read the CPU calibration EEPROM data
614 * from the device-tree
616 static int read_eeprom(int cpu
, struct mpu_data
*out
)
618 struct device_node
*np
;
623 /* prom.c routine for finding a node by path is a bit brain dead
624 * and requires exact @xxx unit numbers. This is a bit ugly but
625 * will work for these machines
627 sprintf(nodename
, "/u3@0,f8000000/i2c@f8001000/cpuid@a%d", cpu
? 2 : 0);
628 np
= of_find_node_by_path(nodename
);
630 printk(KERN_ERR
"therm_pm72: Failed to retrieve cpuid node from device-tree\n");
633 data
= (u8
*)get_property(np
, "cpuid", &len
);
635 printk(KERN_ERR
"therm_pm72: Failed to retrieve cpuid property from device-tree\n");
639 memcpy(out
, data
, sizeof(struct mpu_data
));
645 static void fetch_cpu_pumps_minmax(void)
647 struct cpu_pid_state
*state0
= &cpu_state
[0];
648 struct cpu_pid_state
*state1
= &cpu_state
[1];
649 u16 pump_min
= 0, pump_max
= 0xffff;
652 /* Try to fetch pumps min/max infos from eeprom */
654 memcpy(&tmp
, &state0
->mpu
.processor_part_num
, 8);
655 if (tmp
[0] != 0xffff && tmp
[1] != 0xffff) {
656 pump_min
= max(pump_min
, tmp
[0]);
657 pump_max
= min(pump_max
, tmp
[1]);
659 if (tmp
[2] != 0xffff && tmp
[3] != 0xffff) {
660 pump_min
= max(pump_min
, tmp
[2]);
661 pump_max
= min(pump_max
, tmp
[3]);
664 /* Double check the values, this _IS_ needed as the EEPROM on
665 * some dual 2.5Ghz G5s seem, at least, to have both min & max
666 * same to the same value ... (grrrr)
668 if (pump_min
== pump_max
|| pump_min
== 0 || pump_max
== 0xffff) {
669 pump_min
= CPU_PUMP_OUTPUT_MIN
;
670 pump_max
= CPU_PUMP_OUTPUT_MAX
;
673 state0
->pump_min
= state1
->pump_min
= pump_min
;
674 state0
->pump_max
= state1
->pump_max
= pump_max
;
678 * Now, unfortunately, sysfs doesn't give us a nice void * we could
679 * pass around to the attribute functions, so we don't really have
680 * choice but implement a bunch of them...
682 * That sucks a bit, we take the lock because FIX32TOPRINT evaluates
683 * the input twice... I accept patches :)
685 #define BUILD_SHOW_FUNC_FIX(name, data) \
686 static ssize_t show_##name(struct device *dev, struct device_attribute *attr, char *buf) \
689 down(&driver_lock); \
690 r = sprintf(buf, "%d.%03d", FIX32TOPRINT(data)); \
694 #define BUILD_SHOW_FUNC_INT(name, data) \
695 static ssize_t show_##name(struct device *dev, struct device_attribute *attr, char *buf) \
697 return sprintf(buf, "%d", data); \
700 BUILD_SHOW_FUNC_FIX(cpu0_temperature
, cpu_state
[0].last_temp
)
701 BUILD_SHOW_FUNC_FIX(cpu0_voltage
, cpu_state
[0].voltage
)
702 BUILD_SHOW_FUNC_FIX(cpu0_current
, cpu_state
[0].current_a
)
703 BUILD_SHOW_FUNC_INT(cpu0_exhaust_fan_rpm
, cpu_state
[0].rpm
)
704 BUILD_SHOW_FUNC_INT(cpu0_intake_fan_rpm
, cpu_state
[0].intake_rpm
)
706 BUILD_SHOW_FUNC_FIX(cpu1_temperature
, cpu_state
[1].last_temp
)
707 BUILD_SHOW_FUNC_FIX(cpu1_voltage
, cpu_state
[1].voltage
)
708 BUILD_SHOW_FUNC_FIX(cpu1_current
, cpu_state
[1].current_a
)
709 BUILD_SHOW_FUNC_INT(cpu1_exhaust_fan_rpm
, cpu_state
[1].rpm
)
710 BUILD_SHOW_FUNC_INT(cpu1_intake_fan_rpm
, cpu_state
[1].intake_rpm
)
712 BUILD_SHOW_FUNC_FIX(backside_temperature
, backside_state
.last_temp
)
713 BUILD_SHOW_FUNC_INT(backside_fan_pwm
, backside_state
.pwm
)
715 BUILD_SHOW_FUNC_FIX(drives_temperature
, drives_state
.last_temp
)
716 BUILD_SHOW_FUNC_INT(drives_fan_rpm
, drives_state
.rpm
)
718 BUILD_SHOW_FUNC_FIX(dimms_temperature
, dimms_state
.last_temp
)
720 static DEVICE_ATTR(cpu0_temperature
,S_IRUGO
,show_cpu0_temperature
,NULL
);
721 static DEVICE_ATTR(cpu0_voltage
,S_IRUGO
,show_cpu0_voltage
,NULL
);
722 static DEVICE_ATTR(cpu0_current
,S_IRUGO
,show_cpu0_current
,NULL
);
723 static DEVICE_ATTR(cpu0_exhaust_fan_rpm
,S_IRUGO
,show_cpu0_exhaust_fan_rpm
,NULL
);
724 static DEVICE_ATTR(cpu0_intake_fan_rpm
,S_IRUGO
,show_cpu0_intake_fan_rpm
,NULL
);
726 static DEVICE_ATTR(cpu1_temperature
,S_IRUGO
,show_cpu1_temperature
,NULL
);
727 static DEVICE_ATTR(cpu1_voltage
,S_IRUGO
,show_cpu1_voltage
,NULL
);
728 static DEVICE_ATTR(cpu1_current
,S_IRUGO
,show_cpu1_current
,NULL
);
729 static DEVICE_ATTR(cpu1_exhaust_fan_rpm
,S_IRUGO
,show_cpu1_exhaust_fan_rpm
,NULL
);
730 static DEVICE_ATTR(cpu1_intake_fan_rpm
,S_IRUGO
,show_cpu1_intake_fan_rpm
,NULL
);
732 static DEVICE_ATTR(backside_temperature
,S_IRUGO
,show_backside_temperature
,NULL
);
733 static DEVICE_ATTR(backside_fan_pwm
,S_IRUGO
,show_backside_fan_pwm
,NULL
);
735 static DEVICE_ATTR(drives_temperature
,S_IRUGO
,show_drives_temperature
,NULL
);
736 static DEVICE_ATTR(drives_fan_rpm
,S_IRUGO
,show_drives_fan_rpm
,NULL
);
738 static DEVICE_ATTR(dimms_temperature
,S_IRUGO
,show_dimms_temperature
,NULL
);
741 * CPUs fans control loop
744 static int do_read_one_cpu_values(struct cpu_pid_state
*state
, s32
*temp
, s32
*power
)
746 s32 ltemp
, volts
, amps
;
749 /* Default (in case of error) */
750 *temp
= state
->cur_temp
;
751 *power
= state
->cur_power
;
753 if (cpu_pid_type
== CPU_PID_TYPE_RACKMAC
)
754 index
= (state
->index
== 0) ?
755 CPU_A1_FAN_RPM_INDEX
: CPU_B1_FAN_RPM_INDEX
;
757 index
= (state
->index
== 0) ?
758 CPUA_EXHAUST_FAN_RPM_INDEX
: CPUB_EXHAUST_FAN_RPM_INDEX
;
760 /* Read current fan status */
761 rc
= get_rpm_fan(index
, !RPM_PID_USE_ACTUAL_SPEED
);
763 /* XXX What do we do now ? Nothing for now, keep old value, but
764 * return error upstream
766 DBG(" cpu %d, fan reading error !\n", state
->index
);
769 DBG(" cpu %d, exhaust RPM: %d\n", state
->index
, state
->rpm
);
772 /* Get some sensor readings and scale it */
773 ltemp
= read_smon_adc(state
, 1);
775 /* XXX What do we do now ? */
779 DBG(" cpu %d, temp reading error !\n", state
->index
);
781 /* Fixup temperature according to diode calibration
783 DBG(" cpu %d, temp raw: %04x, m_diode: %04x, b_diode: %04x\n",
785 ltemp
, state
->mpu
.mdiode
, state
->mpu
.bdiode
);
786 *temp
= ((s32
)ltemp
* (s32
)state
->mpu
.mdiode
+ ((s32
)state
->mpu
.bdiode
<< 12)) >> 2;
787 state
->last_temp
= *temp
;
788 DBG(" temp: %d.%03d\n", FIX32TOPRINT((*temp
)));
792 * Read voltage & current and calculate power
794 volts
= read_smon_adc(state
, 3);
795 amps
= read_smon_adc(state
, 4);
797 /* Scale voltage and current raw sensor values according to fixed scales
798 * obtained in Darwin and calculate power from I and V
800 volts
*= ADC_CPU_VOLTAGE_SCALE
;
801 amps
*= ADC_CPU_CURRENT_SCALE
;
802 *power
= (((u64
)volts
) * ((u64
)amps
)) >> 16;
803 state
->voltage
= volts
;
804 state
->current_a
= amps
;
805 state
->last_power
= *power
;
807 DBG(" cpu %d, current: %d.%03d, voltage: %d.%03d, power: %d.%03d W\n",
808 state
->index
, FIX32TOPRINT(state
->current_a
),
809 FIX32TOPRINT(state
->voltage
), FIX32TOPRINT(*power
));
814 static void do_cpu_pid(struct cpu_pid_state
*state
, s32 temp
, s32 power
)
816 s32 power_target
, integral
, derivative
, proportional
, adj_in_target
, sval
;
817 s64 integ_p
, deriv_p
, prop_p
, sum
;
820 /* Calculate power target value (could be done once for all)
821 * and convert to a 16.16 fp number
823 power_target
= ((u32
)(state
->mpu
.pmaxh
- state
->mpu
.padjmax
)) << 16;
824 DBG(" power target: %d.%03d, error: %d.%03d\n",
825 FIX32TOPRINT(power_target
), FIX32TOPRINT(power_target
- power
));
827 /* Store temperature and power in history array */
828 state
->cur_temp
= (state
->cur_temp
+ 1) % CPU_TEMP_HISTORY_SIZE
;
829 state
->temp_history
[state
->cur_temp
] = temp
;
830 state
->cur_power
= (state
->cur_power
+ 1) % state
->count_power
;
831 state
->power_history
[state
->cur_power
] = power
;
832 state
->error_history
[state
->cur_power
] = power_target
- power
;
834 /* If first loop, fill the history table */
836 for (i
= 0; i
< (state
->count_power
- 1); i
++) {
837 state
->cur_power
= (state
->cur_power
+ 1) % state
->count_power
;
838 state
->power_history
[state
->cur_power
] = power
;
839 state
->error_history
[state
->cur_power
] = power_target
- power
;
841 for (i
= 0; i
< (CPU_TEMP_HISTORY_SIZE
- 1); i
++) {
842 state
->cur_temp
= (state
->cur_temp
+ 1) % CPU_TEMP_HISTORY_SIZE
;
843 state
->temp_history
[state
->cur_temp
] = temp
;
848 /* Calculate the integral term normally based on the "power" values */
851 for (i
= 0; i
< state
->count_power
; i
++)
852 integral
+= state
->error_history
[i
];
853 integral
*= CPU_PID_INTERVAL
;
854 DBG(" integral: %08x\n", integral
);
856 /* Calculate the adjusted input (sense value).
859 * so the result is 28.36
861 * input target is mpu.ttarget, input max is mpu.tmax
863 integ_p
= ((s64
)state
->mpu
.pid_gr
) * (s64
)integral
;
864 DBG(" integ_p: %d\n", (int)(integ_p
>> 36));
865 sval
= (state
->mpu
.tmax
<< 16) - ((integ_p
>> 20) & 0xffffffff);
866 adj_in_target
= (state
->mpu
.ttarget
<< 16);
867 if (adj_in_target
> sval
)
868 adj_in_target
= sval
;
869 DBG(" adj_in_target: %d.%03d, ttarget: %d\n", FIX32TOPRINT(adj_in_target
),
872 /* Calculate the derivative term */
873 derivative
= state
->temp_history
[state
->cur_temp
] -
874 state
->temp_history
[(state
->cur_temp
+ CPU_TEMP_HISTORY_SIZE
- 1)
875 % CPU_TEMP_HISTORY_SIZE
];
876 derivative
/= CPU_PID_INTERVAL
;
877 deriv_p
= ((s64
)state
->mpu
.pid_gd
) * (s64
)derivative
;
878 DBG(" deriv_p: %d\n", (int)(deriv_p
>> 36));
881 /* Calculate the proportional term */
882 proportional
= temp
- adj_in_target
;
883 prop_p
= ((s64
)state
->mpu
.pid_gp
) * (s64
)proportional
;
884 DBG(" prop_p: %d\n", (int)(prop_p
>> 36));
890 DBG(" sum: %d\n", (int)sum
);
891 state
->rpm
+= (s32
)sum
;
894 static void do_monitor_cpu_combined(void)
896 struct cpu_pid_state
*state0
= &cpu_state
[0];
897 struct cpu_pid_state
*state1
= &cpu_state
[1];
898 s32 temp0
, power0
, temp1
, power1
;
899 s32 temp_combi
, power_combi
;
900 int rc
, intake
, pump
;
902 rc
= do_read_one_cpu_values(state0
, &temp0
, &power0
);
904 /* XXX What do we do now ? */
906 state1
->overtemp
= 0;
907 rc
= do_read_one_cpu_values(state1
, &temp1
, &power1
);
909 /* XXX What do we do now ? */
911 if (state1
->overtemp
)
914 temp_combi
= max(temp0
, temp1
);
915 power_combi
= max(power0
, power1
);
917 /* Check tmax, increment overtemp if we are there. At tmax+8, we go
918 * full blown immediately and try to trigger a shutdown
920 if (temp_combi
>= ((state0
->mpu
.tmax
+ 8) << 16)) {
921 printk(KERN_WARNING
"Warning ! Temperature way above maximum (%d) !\n",
923 state0
->overtemp
+= CPU_MAX_OVERTEMP
/ 4;
924 } else if (temp_combi
> (state0
->mpu
.tmax
<< 16))
927 state0
->overtemp
= 0;
928 if (state0
->overtemp
>= CPU_MAX_OVERTEMP
)
930 if (state0
->overtemp
> 0) {
931 state0
->rpm
= state0
->mpu
.rmaxn_exhaust_fan
;
932 state0
->intake_rpm
= intake
= state0
->mpu
.rmaxn_intake_fan
;
933 pump
= state0
->pump_max
;
938 do_cpu_pid(state0
, temp_combi
, power_combi
);
941 state0
->rpm
= max(state0
->rpm
, (int)state0
->mpu
.rminn_exhaust_fan
);
942 state0
->rpm
= min(state0
->rpm
, (int)state0
->mpu
.rmaxn_exhaust_fan
);
944 /* Calculate intake fan speed */
945 intake
= (state0
->rpm
* CPU_INTAKE_SCALE
) >> 16;
946 intake
= max(intake
, (int)state0
->mpu
.rminn_intake_fan
);
947 intake
= min(intake
, (int)state0
->mpu
.rmaxn_intake_fan
);
948 state0
->intake_rpm
= intake
;
950 /* Calculate pump speed */
951 pump
= (state0
->rpm
* state0
->pump_max
) /
952 state0
->mpu
.rmaxn_exhaust_fan
;
953 pump
= min(pump
, state0
->pump_max
);
954 pump
= max(pump
, state0
->pump_min
);
957 /* We copy values from state 0 to state 1 for /sysfs */
958 state1
->rpm
= state0
->rpm
;
959 state1
->intake_rpm
= state0
->intake_rpm
;
961 DBG("** CPU %d RPM: %d Ex, %d, Pump: %d, In, overtemp: %d\n",
962 state1
->index
, (int)state1
->rpm
, intake
, pump
, state1
->overtemp
);
964 /* We should check for errors, shouldn't we ? But then, what
965 * do we do once the error occurs ? For FCU notified fan
966 * failures (-EFAULT) we probably want to notify userland
969 set_rpm_fan(CPUA_INTAKE_FAN_RPM_INDEX
, intake
);
970 set_rpm_fan(CPUA_EXHAUST_FAN_RPM_INDEX
, state0
->rpm
);
971 set_rpm_fan(CPUB_INTAKE_FAN_RPM_INDEX
, intake
);
972 set_rpm_fan(CPUB_EXHAUST_FAN_RPM_INDEX
, state0
->rpm
);
974 if (fcu_fans
[CPUA_PUMP_RPM_INDEX
].id
!= FCU_FAN_ABSENT_ID
)
975 set_rpm_fan(CPUA_PUMP_RPM_INDEX
, pump
);
976 if (fcu_fans
[CPUB_PUMP_RPM_INDEX
].id
!= FCU_FAN_ABSENT_ID
)
977 set_rpm_fan(CPUB_PUMP_RPM_INDEX
, pump
);
980 static void do_monitor_cpu_split(struct cpu_pid_state
*state
)
985 /* Read current fan status */
986 rc
= do_read_one_cpu_values(state
, &temp
, &power
);
988 /* XXX What do we do now ? */
991 /* Check tmax, increment overtemp if we are there. At tmax+8, we go
992 * full blown immediately and try to trigger a shutdown
994 if (temp
>= ((state
->mpu
.tmax
+ 8) << 16)) {
995 printk(KERN_WARNING
"Warning ! CPU %d temperature way above maximum"
997 state
->index
, temp
>> 16);
998 state
->overtemp
+= CPU_MAX_OVERTEMP
/ 4;
999 } else if (temp
> (state
->mpu
.tmax
<< 16))
1002 state
->overtemp
= 0;
1003 if (state
->overtemp
>= CPU_MAX_OVERTEMP
)
1005 if (state
->overtemp
> 0) {
1006 state
->rpm
= state
->mpu
.rmaxn_exhaust_fan
;
1007 state
->intake_rpm
= intake
= state
->mpu
.rmaxn_intake_fan
;
1012 do_cpu_pid(state
, temp
, power
);
1015 state
->rpm
= max(state
->rpm
, (int)state
->mpu
.rminn_exhaust_fan
);
1016 state
->rpm
= min(state
->rpm
, (int)state
->mpu
.rmaxn_exhaust_fan
);
1018 /* Calculate intake fan */
1019 intake
= (state
->rpm
* CPU_INTAKE_SCALE
) >> 16;
1020 intake
= max(intake
, (int)state
->mpu
.rminn_intake_fan
);
1021 intake
= min(intake
, (int)state
->mpu
.rmaxn_intake_fan
);
1022 state
->intake_rpm
= intake
;
1025 DBG("** CPU %d RPM: %d Ex, %d In, overtemp: %d\n",
1026 state
->index
, (int)state
->rpm
, intake
, state
->overtemp
);
1028 /* We should check for errors, shouldn't we ? But then, what
1029 * do we do once the error occurs ? For FCU notified fan
1030 * failures (-EFAULT) we probably want to notify userland
1033 if (state
->index
== 0) {
1034 set_rpm_fan(CPUA_INTAKE_FAN_RPM_INDEX
, intake
);
1035 set_rpm_fan(CPUA_EXHAUST_FAN_RPM_INDEX
, state
->rpm
);
1037 set_rpm_fan(CPUB_INTAKE_FAN_RPM_INDEX
, intake
);
1038 set_rpm_fan(CPUB_EXHAUST_FAN_RPM_INDEX
, state
->rpm
);
1042 static void do_monitor_cpu_rack(struct cpu_pid_state
*state
)
1044 s32 temp
, power
, fan_min
;
1047 /* Read current fan status */
1048 rc
= do_read_one_cpu_values(state
, &temp
, &power
);
1050 /* XXX What do we do now ? */
1053 /* Check tmax, increment overtemp if we are there. At tmax+8, we go
1054 * full blown immediately and try to trigger a shutdown
1056 if (temp
>= ((state
->mpu
.tmax
+ 8) << 16)) {
1057 printk(KERN_WARNING
"Warning ! CPU %d temperature way above maximum"
1059 state
->index
, temp
>> 16);
1060 state
->overtemp
= CPU_MAX_OVERTEMP
/ 4;
1061 } else if (temp
> (state
->mpu
.tmax
<< 16))
1064 state
->overtemp
= 0;
1065 if (state
->overtemp
>= CPU_MAX_OVERTEMP
)
1067 if (state
->overtemp
> 0) {
1068 state
->rpm
= state
->intake_rpm
= state
->mpu
.rmaxn_intake_fan
;
1073 do_cpu_pid(state
, temp
, power
);
1075 /* Check clamp from dimms */
1076 fan_min
= dimm_output_clamp
;
1077 fan_min
= max(fan_min
, (int)state
->mpu
.rminn_intake_fan
);
1079 state
->rpm
= max(state
->rpm
, (int)fan_min
);
1080 state
->rpm
= min(state
->rpm
, (int)state
->mpu
.rmaxn_intake_fan
);
1081 state
->intake_rpm
= state
->rpm
;
1084 DBG("** CPU %d RPM: %d overtemp: %d\n",
1085 state
->index
, (int)state
->rpm
, state
->overtemp
);
1087 /* We should check for errors, shouldn't we ? But then, what
1088 * do we do once the error occurs ? For FCU notified fan
1089 * failures (-EFAULT) we probably want to notify userland
1092 if (state
->index
== 0) {
1093 set_rpm_fan(CPU_A1_FAN_RPM_INDEX
, state
->rpm
);
1094 set_rpm_fan(CPU_A2_FAN_RPM_INDEX
, state
->rpm
);
1095 set_rpm_fan(CPU_A3_FAN_RPM_INDEX
, state
->rpm
);
1097 set_rpm_fan(CPU_B1_FAN_RPM_INDEX
, state
->rpm
);
1098 set_rpm_fan(CPU_B2_FAN_RPM_INDEX
, state
->rpm
);
1099 set_rpm_fan(CPU_B3_FAN_RPM_INDEX
, state
->rpm
);
1104 * Initialize the state structure for one CPU control loop
1106 static int init_cpu_state(struct cpu_pid_state
*state
, int index
)
1108 state
->index
= index
;
1110 state
->rpm
= (cpu_pid_type
== CPU_PID_TYPE_RACKMAC
) ? 4000 : 1000;
1111 state
->overtemp
= 0;
1112 state
->adc_config
= 0x00;
1116 state
->monitor
= attach_i2c_chip(SUPPLY_MONITOR_ID
, "CPU0_monitor");
1117 else if (index
== 1)
1118 state
->monitor
= attach_i2c_chip(SUPPLY_MONITORB_ID
, "CPU1_monitor");
1119 if (state
->monitor
== NULL
)
1122 if (read_eeprom(index
, &state
->mpu
))
1125 state
->count_power
= state
->mpu
.tguardband
;
1126 if (state
->count_power
> CPU_POWER_HISTORY_SIZE
) {
1127 printk(KERN_WARNING
"Warning ! too many power history slots\n");
1128 state
->count_power
= CPU_POWER_HISTORY_SIZE
;
1130 DBG("CPU %d Using %d power history entries\n", index
, state
->count_power
);
1133 device_create_file(&of_dev
->dev
, &dev_attr_cpu0_temperature
);
1134 device_create_file(&of_dev
->dev
, &dev_attr_cpu0_voltage
);
1135 device_create_file(&of_dev
->dev
, &dev_attr_cpu0_current
);
1136 device_create_file(&of_dev
->dev
, &dev_attr_cpu0_exhaust_fan_rpm
);
1137 device_create_file(&of_dev
->dev
, &dev_attr_cpu0_intake_fan_rpm
);
1139 device_create_file(&of_dev
->dev
, &dev_attr_cpu1_temperature
);
1140 device_create_file(&of_dev
->dev
, &dev_attr_cpu1_voltage
);
1141 device_create_file(&of_dev
->dev
, &dev_attr_cpu1_current
);
1142 device_create_file(&of_dev
->dev
, &dev_attr_cpu1_exhaust_fan_rpm
);
1143 device_create_file(&of_dev
->dev
, &dev_attr_cpu1_intake_fan_rpm
);
1149 detach_i2c_chip(state
->monitor
);
1150 state
->monitor
= NULL
;
1156 * Dispose of the state data for one CPU control loop
1158 static void dispose_cpu_state(struct cpu_pid_state
*state
)
1160 if (state
->monitor
== NULL
)
1163 if (state
->index
== 0) {
1164 device_remove_file(&of_dev
->dev
, &dev_attr_cpu0_temperature
);
1165 device_remove_file(&of_dev
->dev
, &dev_attr_cpu0_voltage
);
1166 device_remove_file(&of_dev
->dev
, &dev_attr_cpu0_current
);
1167 device_remove_file(&of_dev
->dev
, &dev_attr_cpu0_exhaust_fan_rpm
);
1168 device_remove_file(&of_dev
->dev
, &dev_attr_cpu0_intake_fan_rpm
);
1170 device_remove_file(&of_dev
->dev
, &dev_attr_cpu1_temperature
);
1171 device_remove_file(&of_dev
->dev
, &dev_attr_cpu1_voltage
);
1172 device_remove_file(&of_dev
->dev
, &dev_attr_cpu1_current
);
1173 device_remove_file(&of_dev
->dev
, &dev_attr_cpu1_exhaust_fan_rpm
);
1174 device_remove_file(&of_dev
->dev
, &dev_attr_cpu1_intake_fan_rpm
);
1177 detach_i2c_chip(state
->monitor
);
1178 state
->monitor
= NULL
;
1182 * Motherboard backside & U3 heatsink fan control loop
1184 static void do_monitor_backside(struct backside_pid_state
*state
)
1186 s32 temp
, integral
, derivative
, fan_min
;
1187 s64 integ_p
, deriv_p
, prop_p
, sum
;
1190 if (--state
->ticks
!= 0)
1192 state
->ticks
= backside_params
.interval
;
1196 /* Check fan status */
1197 rc
= get_pwm_fan(BACKSIDE_FAN_PWM_INDEX
);
1199 printk(KERN_WARNING
"Error %d reading backside fan !\n", rc
);
1200 /* XXX What do we do now ? */
1203 DBG(" current pwm: %d\n", state
->pwm
);
1205 /* Get some sensor readings */
1206 temp
= i2c_smbus_read_byte_data(state
->monitor
, MAX6690_EXT_TEMP
) << 16;
1207 state
->last_temp
= temp
;
1208 DBG(" temp: %d.%03d, target: %d.%03d\n", FIX32TOPRINT(temp
),
1209 FIX32TOPRINT(backside_params
.input_target
));
1211 /* Store temperature and error in history array */
1212 state
->cur_sample
= (state
->cur_sample
+ 1) % BACKSIDE_PID_HISTORY_SIZE
;
1213 state
->sample_history
[state
->cur_sample
] = temp
;
1214 state
->error_history
[state
->cur_sample
] = temp
- backside_params
.input_target
;
1216 /* If first loop, fill the history table */
1218 for (i
= 0; i
< (BACKSIDE_PID_HISTORY_SIZE
- 1); i
++) {
1219 state
->cur_sample
= (state
->cur_sample
+ 1) %
1220 BACKSIDE_PID_HISTORY_SIZE
;
1221 state
->sample_history
[state
->cur_sample
] = temp
;
1222 state
->error_history
[state
->cur_sample
] =
1223 temp
- backside_params
.input_target
;
1228 /* Calculate the integral term */
1231 for (i
= 0; i
< BACKSIDE_PID_HISTORY_SIZE
; i
++)
1232 integral
+= state
->error_history
[i
];
1233 integral
*= backside_params
.interval
;
1234 DBG(" integral: %08x\n", integral
);
1235 integ_p
= ((s64
)backside_params
.G_r
) * (s64
)integral
;
1236 DBG(" integ_p: %d\n", (int)(integ_p
>> 36));
1239 /* Calculate the derivative term */
1240 derivative
= state
->error_history
[state
->cur_sample
] -
1241 state
->error_history
[(state
->cur_sample
+ BACKSIDE_PID_HISTORY_SIZE
- 1)
1242 % BACKSIDE_PID_HISTORY_SIZE
];
1243 derivative
/= backside_params
.interval
;
1244 deriv_p
= ((s64
)backside_params
.G_d
) * (s64
)derivative
;
1245 DBG(" deriv_p: %d\n", (int)(deriv_p
>> 36));
1248 /* Calculate the proportional term */
1249 prop_p
= ((s64
)backside_params
.G_p
) * (s64
)(state
->error_history
[state
->cur_sample
]);
1250 DBG(" prop_p: %d\n", (int)(prop_p
>> 36));
1256 DBG(" sum: %d\n", (int)sum
);
1257 if (backside_params
.additive
)
1258 state
->pwm
+= (s32
)sum
;
1262 /* Check for clamp */
1263 fan_min
= (dimm_output_clamp
* 100) / 14000;
1264 fan_min
= max(fan_min
, backside_params
.output_min
);
1266 state
->pwm
= max(state
->pwm
, fan_min
);
1267 state
->pwm
= min(state
->pwm
, backside_params
.output_max
);
1269 DBG("** BACKSIDE PWM: %d\n", (int)state
->pwm
);
1270 set_pwm_fan(BACKSIDE_FAN_PWM_INDEX
, state
->pwm
);
1274 * Initialize the state structure for the backside fan control loop
1276 static int init_backside_state(struct backside_pid_state
*state
)
1278 struct device_node
*u3
;
1279 int u3h
= 1; /* conservative by default */
1282 * There are different PID params for machines with U3 and machines
1283 * with U3H, pick the right ones now
1285 u3
= of_find_node_by_path("/u3@0,f8000000");
1287 u32
*vers
= (u32
*)get_property(u3
, "device-rev", NULL
);
1289 if (((*vers
) & 0x3f) < 0x34)
1295 backside_params
.G_d
= BACKSIDE_PID_RACK_G_d
;
1296 backside_params
.input_target
= BACKSIDE_PID_RACK_INPUT_TARGET
;
1297 backside_params
.output_min
= BACKSIDE_PID_U3H_OUTPUT_MIN
;
1298 backside_params
.interval
= BACKSIDE_PID_RACK_INTERVAL
;
1299 backside_params
.G_p
= BACKSIDE_PID_RACK_G_p
;
1300 backside_params
.G_r
= BACKSIDE_PID_G_r
;
1301 backside_params
.output_max
= BACKSIDE_PID_OUTPUT_MAX
;
1302 backside_params
.additive
= 0;
1304 backside_params
.G_d
= BACKSIDE_PID_U3H_G_d
;
1305 backside_params
.input_target
= BACKSIDE_PID_U3H_INPUT_TARGET
;
1306 backside_params
.output_min
= BACKSIDE_PID_U3H_OUTPUT_MIN
;
1307 backside_params
.interval
= BACKSIDE_PID_INTERVAL
;
1308 backside_params
.G_p
= BACKSIDE_PID_G_p
;
1309 backside_params
.G_r
= BACKSIDE_PID_G_r
;
1310 backside_params
.output_max
= BACKSIDE_PID_OUTPUT_MAX
;
1311 backside_params
.additive
= 1;
1313 backside_params
.G_d
= BACKSIDE_PID_U3_G_d
;
1314 backside_params
.input_target
= BACKSIDE_PID_U3_INPUT_TARGET
;
1315 backside_params
.output_min
= BACKSIDE_PID_U3_OUTPUT_MIN
;
1316 backside_params
.interval
= BACKSIDE_PID_INTERVAL
;
1317 backside_params
.G_p
= BACKSIDE_PID_G_p
;
1318 backside_params
.G_r
= BACKSIDE_PID_G_r
;
1319 backside_params
.output_max
= BACKSIDE_PID_OUTPUT_MAX
;
1320 backside_params
.additive
= 1;
1327 state
->monitor
= attach_i2c_chip(BACKSIDE_MAX_ID
, "backside_temp");
1328 if (state
->monitor
== NULL
)
1331 device_create_file(&of_dev
->dev
, &dev_attr_backside_temperature
);
1332 device_create_file(&of_dev
->dev
, &dev_attr_backside_fan_pwm
);
1338 * Dispose of the state data for the backside control loop
1340 static void dispose_backside_state(struct backside_pid_state
*state
)
1342 if (state
->monitor
== NULL
)
1345 device_remove_file(&of_dev
->dev
, &dev_attr_backside_temperature
);
1346 device_remove_file(&of_dev
->dev
, &dev_attr_backside_fan_pwm
);
1348 detach_i2c_chip(state
->monitor
);
1349 state
->monitor
= NULL
;
1353 * Drives bay fan control loop
1355 static void do_monitor_drives(struct drives_pid_state
*state
)
1357 s32 temp
, integral
, derivative
;
1358 s64 integ_p
, deriv_p
, prop_p
, sum
;
1361 if (--state
->ticks
!= 0)
1363 state
->ticks
= DRIVES_PID_INTERVAL
;
1367 /* Check fan status */
1368 rc
= get_rpm_fan(DRIVES_FAN_RPM_INDEX
, !RPM_PID_USE_ACTUAL_SPEED
);
1370 printk(KERN_WARNING
"Error %d reading drives fan !\n", rc
);
1371 /* XXX What do we do now ? */
1374 DBG(" current rpm: %d\n", state
->rpm
);
1376 /* Get some sensor readings */
1377 temp
= le16_to_cpu(i2c_smbus_read_word_data(state
->monitor
, DS1775_TEMP
)) << 8;
1378 state
->last_temp
= temp
;
1379 DBG(" temp: %d.%03d, target: %d.%03d\n", FIX32TOPRINT(temp
),
1380 FIX32TOPRINT(DRIVES_PID_INPUT_TARGET
));
1382 /* Store temperature and error in history array */
1383 state
->cur_sample
= (state
->cur_sample
+ 1) % DRIVES_PID_HISTORY_SIZE
;
1384 state
->sample_history
[state
->cur_sample
] = temp
;
1385 state
->error_history
[state
->cur_sample
] = temp
- DRIVES_PID_INPUT_TARGET
;
1387 /* If first loop, fill the history table */
1389 for (i
= 0; i
< (DRIVES_PID_HISTORY_SIZE
- 1); i
++) {
1390 state
->cur_sample
= (state
->cur_sample
+ 1) %
1391 DRIVES_PID_HISTORY_SIZE
;
1392 state
->sample_history
[state
->cur_sample
] = temp
;
1393 state
->error_history
[state
->cur_sample
] =
1394 temp
- DRIVES_PID_INPUT_TARGET
;
1399 /* Calculate the integral term */
1402 for (i
= 0; i
< DRIVES_PID_HISTORY_SIZE
; i
++)
1403 integral
+= state
->error_history
[i
];
1404 integral
*= DRIVES_PID_INTERVAL
;
1405 DBG(" integral: %08x\n", integral
);
1406 integ_p
= ((s64
)DRIVES_PID_G_r
) * (s64
)integral
;
1407 DBG(" integ_p: %d\n", (int)(integ_p
>> 36));
1410 /* Calculate the derivative term */
1411 derivative
= state
->error_history
[state
->cur_sample
] -
1412 state
->error_history
[(state
->cur_sample
+ DRIVES_PID_HISTORY_SIZE
- 1)
1413 % DRIVES_PID_HISTORY_SIZE
];
1414 derivative
/= DRIVES_PID_INTERVAL
;
1415 deriv_p
= ((s64
)DRIVES_PID_G_d
) * (s64
)derivative
;
1416 DBG(" deriv_p: %d\n", (int)(deriv_p
>> 36));
1419 /* Calculate the proportional term */
1420 prop_p
= ((s64
)DRIVES_PID_G_p
) * (s64
)(state
->error_history
[state
->cur_sample
]);
1421 DBG(" prop_p: %d\n", (int)(prop_p
>> 36));
1427 DBG(" sum: %d\n", (int)sum
);
1428 state
->rpm
+= (s32
)sum
;
1430 state
->rpm
= max(state
->rpm
, DRIVES_PID_OUTPUT_MIN
);
1431 state
->rpm
= min(state
->rpm
, DRIVES_PID_OUTPUT_MAX
);
1433 DBG("** DRIVES RPM: %d\n", (int)state
->rpm
);
1434 set_rpm_fan(DRIVES_FAN_RPM_INDEX
, state
->rpm
);
1438 * Initialize the state structure for the drives bay fan control loop
1440 static int init_drives_state(struct drives_pid_state
*state
)
1446 state
->monitor
= attach_i2c_chip(DRIVES_DALLAS_ID
, "drives_temp");
1447 if (state
->monitor
== NULL
)
1450 device_create_file(&of_dev
->dev
, &dev_attr_drives_temperature
);
1451 device_create_file(&of_dev
->dev
, &dev_attr_drives_fan_rpm
);
1457 * Dispose of the state data for the drives control loop
1459 static void dispose_drives_state(struct drives_pid_state
*state
)
1461 if (state
->monitor
== NULL
)
1464 device_remove_file(&of_dev
->dev
, &dev_attr_drives_temperature
);
1465 device_remove_file(&of_dev
->dev
, &dev_attr_drives_fan_rpm
);
1467 detach_i2c_chip(state
->monitor
);
1468 state
->monitor
= NULL
;
1472 * DIMMs temp control loop
1474 static void do_monitor_dimms(struct dimm_pid_state
*state
)
1476 s32 temp
, integral
, derivative
, fan_min
;
1477 s64 integ_p
, deriv_p
, prop_p
, sum
;
1480 if (--state
->ticks
!= 0)
1482 state
->ticks
= DIMM_PID_INTERVAL
;
1486 DBG(" current value: %d\n", state
->output
);
1488 temp
= read_lm87_reg(state
->monitor
, LM87_INT_TEMP
);
1492 state
->last_temp
= temp
;
1493 DBG(" temp: %d.%03d, target: %d.%03d\n", FIX32TOPRINT(temp
),
1494 FIX32TOPRINT(DIMM_PID_INPUT_TARGET
));
1496 /* Store temperature and error in history array */
1497 state
->cur_sample
= (state
->cur_sample
+ 1) % DIMM_PID_HISTORY_SIZE
;
1498 state
->sample_history
[state
->cur_sample
] = temp
;
1499 state
->error_history
[state
->cur_sample
] = temp
- DIMM_PID_INPUT_TARGET
;
1501 /* If first loop, fill the history table */
1503 for (i
= 0; i
< (DIMM_PID_HISTORY_SIZE
- 1); i
++) {
1504 state
->cur_sample
= (state
->cur_sample
+ 1) %
1505 DIMM_PID_HISTORY_SIZE
;
1506 state
->sample_history
[state
->cur_sample
] = temp
;
1507 state
->error_history
[state
->cur_sample
] =
1508 temp
- DIMM_PID_INPUT_TARGET
;
1513 /* Calculate the integral term */
1516 for (i
= 0; i
< DIMM_PID_HISTORY_SIZE
; i
++)
1517 integral
+= state
->error_history
[i
];
1518 integral
*= DIMM_PID_INTERVAL
;
1519 DBG(" integral: %08x\n", integral
);
1520 integ_p
= ((s64
)DIMM_PID_G_r
) * (s64
)integral
;
1521 DBG(" integ_p: %d\n", (int)(integ_p
>> 36));
1524 /* Calculate the derivative term */
1525 derivative
= state
->error_history
[state
->cur_sample
] -
1526 state
->error_history
[(state
->cur_sample
+ DIMM_PID_HISTORY_SIZE
- 1)
1527 % DIMM_PID_HISTORY_SIZE
];
1528 derivative
/= DIMM_PID_INTERVAL
;
1529 deriv_p
= ((s64
)DIMM_PID_G_d
) * (s64
)derivative
;
1530 DBG(" deriv_p: %d\n", (int)(deriv_p
>> 36));
1533 /* Calculate the proportional term */
1534 prop_p
= ((s64
)DIMM_PID_G_p
) * (s64
)(state
->error_history
[state
->cur_sample
]);
1535 DBG(" prop_p: %d\n", (int)(prop_p
>> 36));
1541 DBG(" sum: %d\n", (int)sum
);
1542 state
->output
= (s32
)sum
;
1543 state
->output
= max(state
->output
, DIMM_PID_OUTPUT_MIN
);
1544 state
->output
= min(state
->output
, DIMM_PID_OUTPUT_MAX
);
1545 dimm_output_clamp
= state
->output
;
1547 DBG("** DIMM clamp value: %d\n", (int)state
->output
);
1549 /* Backside PID is only every 5 seconds, force backside fan clamping now */
1550 fan_min
= (dimm_output_clamp
* 100) / 14000;
1551 fan_min
= max(fan_min
, backside_params
.output_min
);
1552 if (backside_state
.pwm
< fan_min
) {
1553 backside_state
.pwm
= fan_min
;
1554 DBG(" -> applying clamp to backside fan now: %d !\n", fan_min
);
1555 set_pwm_fan(BACKSIDE_FAN_PWM_INDEX
, fan_min
);
1560 * Initialize the state structure for the DIMM temp control loop
1562 static int init_dimms_state(struct dimm_pid_state
*state
)
1566 state
->output
= 4000;
1568 state
->monitor
= attach_i2c_chip(XSERVE_DIMMS_LM87
, "dimms_temp");
1569 if (state
->monitor
== NULL
)
1572 device_create_file(&of_dev
->dev
, &dev_attr_dimms_temperature
);
1578 * Dispose of the state data for the drives control loop
1580 static void dispose_dimms_state(struct dimm_pid_state
*state
)
1582 if (state
->monitor
== NULL
)
1585 device_remove_file(&of_dev
->dev
, &dev_attr_dimms_temperature
);
1587 detach_i2c_chip(state
->monitor
);
1588 state
->monitor
= NULL
;
1591 static int call_critical_overtemp(void)
1593 char *argv
[] = { critical_overtemp_path
, NULL
};
1594 static char *envp
[] = { "HOME=/",
1596 "PATH=/sbin:/usr/sbin:/bin:/usr/bin",
1599 return call_usermodehelper(critical_overtemp_path
, argv
, envp
, 0);
1604 * Here's the kernel thread that calls the various control loops
1606 static int main_control_loop(void *x
)
1610 DBG("main_control_loop started\n");
1614 if (start_fcu() < 0) {
1615 printk(KERN_ERR
"kfand: failed to start FCU\n");
1620 /* Set the PCI fan once for now */
1621 set_pwm_fan(SLOTS_FAN_PWM_INDEX
, SLOTS_FAN_DEFAULT_PWM
);
1623 /* Initialize ADCs */
1624 initialize_adc(&cpu_state
[0]);
1625 if (cpu_state
[1].monitor
!= NULL
)
1626 initialize_adc(&cpu_state
[1]);
1630 while (state
== state_attached
) {
1631 unsigned long elapsed
, start
;
1637 /* First, we always calculate the new DIMMs state on an Xserve */
1639 do_monitor_dimms(&dimms_state
);
1641 /* Then, the CPUs */
1642 if (cpu_pid_type
== CPU_PID_TYPE_COMBINED
)
1643 do_monitor_cpu_combined();
1644 else if (cpu_pid_type
== CPU_PID_TYPE_RACKMAC
) {
1645 do_monitor_cpu_rack(&cpu_state
[0]);
1646 if (cpu_state
[1].monitor
!= NULL
)
1647 do_monitor_cpu_rack(&cpu_state
[1]);
1648 // better deal with UP
1650 do_monitor_cpu_split(&cpu_state
[0]);
1651 if (cpu_state
[1].monitor
!= NULL
)
1652 do_monitor_cpu_split(&cpu_state
[1]);
1653 // better deal with UP
1655 /* Then, the rest */
1656 do_monitor_backside(&backside_state
);
1658 do_monitor_drives(&drives_state
);
1661 if (critical_state
== 1) {
1662 printk(KERN_WARNING
"Temperature control detected a critical condition\n");
1663 printk(KERN_WARNING
"Attempting to shut down...\n");
1664 if (call_critical_overtemp()) {
1665 printk(KERN_WARNING
"Can't call %s, power off now!\n",
1666 critical_overtemp_path
);
1667 machine_power_off();
1670 if (critical_state
> 0)
1672 if (critical_state
> MAX_CRITICAL_STATE
) {
1673 printk(KERN_WARNING
"Shutdown timed out, power off now !\n");
1674 machine_power_off();
1677 // FIXME: Deal with signals
1678 elapsed
= jiffies
- start
;
1680 schedule_timeout_interruptible(HZ
- elapsed
);
1684 DBG("main_control_loop ended\n");
1687 complete_and_exit(&ctrl_complete
, 0);
1691 * Dispose the control loops when tearing down
1693 static void dispose_control_loops(void)
1695 dispose_cpu_state(&cpu_state
[0]);
1696 dispose_cpu_state(&cpu_state
[1]);
1697 dispose_backside_state(&backside_state
);
1698 dispose_drives_state(&drives_state
);
1699 dispose_dimms_state(&dimms_state
);
1703 * Create the control loops. U3-0 i2c bus is up, so we can now
1704 * get to the various sensors
1706 static int create_control_loops(void)
1708 struct device_node
*np
;
1710 /* Count CPUs from the device-tree, we don't care how many are
1711 * actually used by Linux
1714 for (np
= NULL
; NULL
!= (np
= of_find_node_by_type(np
, "cpu"));)
1717 DBG("counted %d CPUs in the device-tree\n", cpu_count
);
1719 /* Decide the type of PID algorithm to use based on the presence of
1720 * the pumps, though that may not be the best way, that is good enough
1724 cpu_pid_type
= CPU_PID_TYPE_RACKMAC
;
1725 else if (machine_is_compatible("PowerMac7,3")
1727 && fcu_fans
[CPUA_PUMP_RPM_INDEX
].id
!= FCU_FAN_ABSENT_ID
1728 && fcu_fans
[CPUB_PUMP_RPM_INDEX
].id
!= FCU_FAN_ABSENT_ID
) {
1729 printk(KERN_INFO
"Liquid cooling pumps detected, using new algorithm !\n");
1730 cpu_pid_type
= CPU_PID_TYPE_COMBINED
;
1732 cpu_pid_type
= CPU_PID_TYPE_SPLIT
;
1734 /* Create control loops for everything. If any fail, everything
1737 if (init_cpu_state(&cpu_state
[0], 0))
1739 if (cpu_pid_type
== CPU_PID_TYPE_COMBINED
)
1740 fetch_cpu_pumps_minmax();
1742 if (cpu_count
> 1 && init_cpu_state(&cpu_state
[1], 1))
1744 if (init_backside_state(&backside_state
))
1746 if (rackmac
&& init_dimms_state(&dimms_state
))
1748 if (!rackmac
&& init_drives_state(&drives_state
))
1751 DBG("all control loops up !\n");
1756 DBG("failure creating control loops, disposing\n");
1758 dispose_control_loops();
1764 * Start the control loops after everything is up, that is create
1765 * the thread that will make them run
1767 static void start_control_loops(void)
1769 init_completion(&ctrl_complete
);
1771 ctrl_task
= kernel_thread(main_control_loop
, NULL
, SIGCHLD
| CLONE_KERNEL
);
1775 * Stop the control loops when tearing down
1777 static void stop_control_loops(void)
1780 wait_for_completion(&ctrl_complete
);
1784 * Attach to the i2c FCU after detecting U3-1 bus
1786 static int attach_fcu(void)
1788 fcu
= attach_i2c_chip(FAN_CTRLER_ID
, "fcu");
1792 DBG("FCU attached\n");
1798 * Detach from the i2c FCU when tearing down
1800 static void detach_fcu(void)
1803 detach_i2c_chip(fcu
);
1808 * Attach to the i2c controller. We probe the various chips based
1809 * on the device-tree nodes and build everything for the driver to
1810 * run, we then kick the driver monitoring thread
1812 static int therm_pm72_attach(struct i2c_adapter
*adapter
)
1817 if (state
== state_detached
)
1818 state
= state_attaching
;
1819 if (state
!= state_attaching
) {
1824 /* Check if we are looking for one of these */
1825 if (u3_0
== NULL
&& !strcmp(adapter
->name
, "u3 0")) {
1827 DBG("found U3-0\n");
1829 if (create_control_loops())
1831 } else if (u3_1
== NULL
&& !strcmp(adapter
->name
, "u3 1")) {
1833 DBG("found U3-1, attaching FCU\n");
1836 } else if (k2
== NULL
&& !strcmp(adapter
->name
, "mac-io 0")) {
1839 if (u3_0
&& rackmac
)
1840 if (create_control_loops())
1843 /* We got all we need, start control loops */
1844 if (u3_0
!= NULL
&& u3_1
!= NULL
&& (k2
|| !rackmac
)) {
1845 DBG("everything up, starting control loops\n");
1846 state
= state_attached
;
1847 start_control_loops();
1855 * Called on every adapter when the driver or the i2c controller
1858 static int therm_pm72_detach(struct i2c_adapter
*adapter
)
1862 if (state
!= state_detached
)
1863 state
= state_detaching
;
1865 /* Stop control loops if any */
1866 DBG("stopping control loops\n");
1868 stop_control_loops();
1871 if (u3_0
!= NULL
&& !strcmp(adapter
->name
, "u3 0")) {
1872 DBG("lost U3-0, disposing control loops\n");
1873 dispose_control_loops();
1877 if (u3_1
!= NULL
&& !strcmp(adapter
->name
, "u3 1")) {
1878 DBG("lost U3-1, detaching FCU\n");
1882 if (u3_0
== NULL
&& u3_1
== NULL
)
1883 state
= state_detached
;
1890 static int fan_check_loc_match(const char *loc
, int fan
)
1895 strlcpy(tmp
, fcu_fans
[fan
].loc
, 64);
1902 if (strcmp(loc
, c
) == 0)
1911 static void fcu_lookup_fans(struct device_node
*fcu_node
)
1913 struct device_node
*np
= NULL
;
1916 /* The table is filled by default with values that are suitable
1917 * for the old machines without device-tree informations. We scan
1918 * the device-tree and override those values with whatever is
1922 DBG("Looking up FCU controls in device-tree...\n");
1924 while ((np
= of_get_next_child(fcu_node
, np
)) != NULL
) {
1929 DBG(" control: %s, type: %s\n", np
->name
, np
->type
);
1931 /* Detect control type */
1932 if (!strcmp(np
->type
, "fan-rpm-control") ||
1933 !strcmp(np
->type
, "fan-rpm"))
1935 if (!strcmp(np
->type
, "fan-pwm-control") ||
1936 !strcmp(np
->type
, "fan-pwm"))
1938 /* Only care about fans for now */
1942 /* Lookup for a matching location */
1943 loc
= (char *)get_property(np
, "location", NULL
);
1944 reg
= (u32
*)get_property(np
, "reg", NULL
);
1945 if (loc
== NULL
|| reg
== NULL
)
1947 DBG(" matching location: %s, reg: 0x%08x\n", loc
, *reg
);
1949 for (i
= 0; i
< FCU_FAN_COUNT
; i
++) {
1952 if (!fan_check_loc_match(loc
, i
))
1954 DBG(" location match, index: %d\n", i
);
1955 fcu_fans
[i
].id
= FCU_FAN_ABSENT_ID
;
1956 if (type
!= fcu_fans
[i
].type
) {
1957 printk(KERN_WARNING
"therm_pm72: Fan type mismatch "
1958 "in device-tree for %s\n", np
->full_name
);
1961 if (type
== FCU_FAN_RPM
)
1962 fan_id
= ((*reg
) - 0x10) / 2;
1964 fan_id
= ((*reg
) - 0x30) / 2;
1966 printk(KERN_WARNING
"therm_pm72: Can't parse "
1967 "fan ID in device-tree for %s\n", np
->full_name
);
1970 DBG(" fan id -> %d, type -> %d\n", fan_id
, type
);
1971 fcu_fans
[i
].id
= fan_id
;
1975 /* Now dump the array */
1976 printk(KERN_INFO
"Detected fan controls:\n");
1977 for (i
= 0; i
< FCU_FAN_COUNT
; i
++) {
1978 if (fcu_fans
[i
].id
== FCU_FAN_ABSENT_ID
)
1980 printk(KERN_INFO
" %d: %s fan, id %d, location: %s\n", i
,
1981 fcu_fans
[i
].type
== FCU_FAN_RPM
? "RPM" : "PWM",
1982 fcu_fans
[i
].id
, fcu_fans
[i
].loc
);
1986 static int fcu_of_probe(struct of_device
* dev
, const struct of_device_id
*match
)
1988 state
= state_detached
;
1990 /* Lookup the fans in the device tree */
1991 fcu_lookup_fans(dev
->node
);
1993 /* Add the driver */
1994 return i2c_add_driver(&therm_pm72_driver
);
1997 static int fcu_of_remove(struct of_device
* dev
)
1999 i2c_del_driver(&therm_pm72_driver
);
2004 static struct of_device_id fcu_match
[] =
2012 static struct of_platform_driver fcu_of_platform_driver
=
2014 .name
= "temperature",
2015 .match_table
= fcu_match
,
2016 .probe
= fcu_of_probe
,
2017 .remove
= fcu_of_remove
2021 * Check machine type, attach to i2c controller
2023 static int __init
therm_pm72_init(void)
2025 struct device_node
*np
;
2027 rackmac
= machine_is_compatible("RackMac3,1");
2029 if (!machine_is_compatible("PowerMac7,2") &&
2030 !machine_is_compatible("PowerMac7,3") &&
2034 printk(KERN_INFO
"PowerMac G5 Thermal control driver %s\n", VERSION
);
2036 np
= of_find_node_by_type(NULL
, "fcu");
2038 /* Some machines have strangely broken device-tree */
2039 np
= of_find_node_by_path("/u3@0,f8000000/i2c@f8001000/fan@15e");
2041 printk(KERN_ERR
"Can't find FCU in device-tree !\n");
2045 of_dev
= of_platform_device_create(np
, "temperature", NULL
);
2046 if (of_dev
== NULL
) {
2047 printk(KERN_ERR
"Can't register FCU platform device !\n");
2051 of_register_driver(&fcu_of_platform_driver
);
2056 static void __exit
therm_pm72_exit(void)
2058 of_unregister_driver(&fcu_of_platform_driver
);
2061 of_device_unregister(of_dev
);
2064 module_init(therm_pm72_init
);
2065 module_exit(therm_pm72_exit
);
2067 MODULE_AUTHOR("Benjamin Herrenschmidt <benh@kernel.crashing.org>");
2068 MODULE_DESCRIPTION("Driver for Apple's PowerMac G5 thermal control");
2069 MODULE_LICENSE("GPL");