1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* |
3 | * Windfarm PowerMac thermal control. |
4 | * Control loops for PowerMac7,2 and 7,3 |
5 | * |
6 | * Copyright (C) 2012 Benjamin Herrenschmidt, IBM Corp. |
7 | */ |
8 | #include <linux/types.h> |
9 | #include <linux/errno.h> |
10 | #include <linux/kernel.h> |
11 | #include <linux/device.h> |
12 | #include <linux/platform_device.h> |
13 | #include <linux/reboot.h> |
14 | |
15 | #include <asm/smu.h> |
16 | |
17 | #include "windfarm.h" |
18 | #include "windfarm_pid.h" |
19 | #include "windfarm_mpu.h" |
20 | |
21 | #define VERSION "1.0" |
22 | |
23 | #undef DEBUG |
24 | #undef LOTSA_DEBUG |
25 | |
26 | #ifdef DEBUG |
27 | #define DBG(args...) printk(args) |
28 | #else |
29 | #define DBG(args...) do { } while(0) |
30 | #endif |
31 | |
32 | #ifdef LOTSA_DEBUG |
33 | #define DBG_LOTS(args...) printk(args) |
34 | #else |
35 | #define DBG_LOTS(args...) do { } while(0) |
36 | #endif |
37 | |
38 | /* define this to force CPU overtemp to 60 degree, useful for testing |
39 | * the overtemp code |
40 | */ |
41 | #undef HACKED_OVERTEMP |
42 | |
43 | /* We currently only handle 2 chips */ |
44 | #define NR_CHIPS 2 |
45 | #define NR_CPU_FANS 3 * NR_CHIPS |
46 | |
47 | /* Controls and sensors */ |
48 | static struct wf_sensor *sens_cpu_temp[NR_CHIPS]; |
49 | static struct wf_sensor *sens_cpu_volts[NR_CHIPS]; |
50 | static struct wf_sensor *sens_cpu_amps[NR_CHIPS]; |
51 | static struct wf_sensor *backside_temp; |
52 | static struct wf_sensor *drives_temp; |
53 | |
54 | static struct wf_control *cpu_front_fans[NR_CHIPS]; |
55 | static struct wf_control *cpu_rear_fans[NR_CHIPS]; |
56 | static struct wf_control *cpu_pumps[NR_CHIPS]; |
57 | static struct wf_control *backside_fan; |
58 | static struct wf_control *drives_fan; |
59 | static struct wf_control *slots_fan; |
60 | static struct wf_control *cpufreq_clamp; |
61 | |
62 | /* We keep a temperature history for average calculation of 180s */ |
63 | #define CPU_TEMP_HIST_SIZE 180 |
64 | |
65 | /* Fixed speed for slot fan */ |
66 | #define SLOTS_FAN_DEFAULT_PWM 40 |
67 | |
68 | /* Scale value for CPU intake fans */ |
69 | #define CPU_INTAKE_SCALE 0x0000f852 |
70 | |
71 | /* PID loop state */ |
72 | static const struct mpu_data *cpu_mpu_data[NR_CHIPS]; |
73 | static struct wf_cpu_pid_state cpu_pid[NR_CHIPS]; |
74 | static bool cpu_pid_combined; |
75 | static u32 cpu_thist[CPU_TEMP_HIST_SIZE]; |
76 | static int cpu_thist_pt; |
77 | static s64 cpu_thist_total; |
78 | static s32 cpu_all_tmax = 100 << 16; |
79 | static struct wf_pid_state backside_pid; |
80 | static int backside_tick; |
81 | static struct wf_pid_state drives_pid; |
82 | static int drives_tick; |
83 | |
84 | static int nr_chips; |
85 | static bool have_all_controls; |
86 | static bool have_all_sensors; |
87 | static bool started; |
88 | |
89 | static int failure_state; |
90 | #define FAILURE_SENSOR 1 |
91 | #define FAILURE_FAN 2 |
92 | #define FAILURE_PERM 4 |
93 | #define FAILURE_LOW_OVERTEMP 8 |
94 | #define FAILURE_HIGH_OVERTEMP 16 |
95 | |
96 | /* Overtemp values */ |
97 | #define LOW_OVER_AVERAGE 0 |
98 | #define LOW_OVER_IMMEDIATE (10 << 16) |
99 | #define LOW_OVER_CLEAR ((-10) << 16) |
100 | #define HIGH_OVER_IMMEDIATE (14 << 16) |
101 | #define HIGH_OVER_AVERAGE (10 << 16) |
102 | #define HIGH_OVER_IMMEDIATE (14 << 16) |
103 | |
104 | |
105 | static void cpu_max_all_fans(void) |
106 | { |
107 | int i; |
108 | |
109 | /* We max all CPU fans in case of a sensor error. We also do the |
110 | * cpufreq clamping now, even if it's supposedly done later by the |
111 | * generic code anyway, we do it earlier here to react faster |
112 | */ |
113 | if (cpufreq_clamp) |
114 | wf_control_set_max(ct: cpufreq_clamp); |
115 | for (i = 0; i < nr_chips; i++) { |
116 | if (cpu_front_fans[i]) |
117 | wf_control_set_max(ct: cpu_front_fans[i]); |
118 | if (cpu_rear_fans[i]) |
119 | wf_control_set_max(ct: cpu_rear_fans[i]); |
120 | if (cpu_pumps[i]) |
121 | wf_control_set_max(ct: cpu_pumps[i]); |
122 | } |
123 | } |
124 | |
125 | static int cpu_check_overtemp(s32 temp) |
126 | { |
127 | int new_state = 0; |
128 | s32 t_avg, t_old; |
129 | static bool first = true; |
130 | |
131 | /* First check for immediate overtemps */ |
132 | if (temp >= (cpu_all_tmax + LOW_OVER_IMMEDIATE)) { |
133 | new_state |= FAILURE_LOW_OVERTEMP; |
134 | if ((failure_state & FAILURE_LOW_OVERTEMP) == 0) |
135 | printk(KERN_ERR "windfarm: Overtemp due to immediate CPU" |
136 | " temperature !\n" ); |
137 | } |
138 | if (temp >= (cpu_all_tmax + HIGH_OVER_IMMEDIATE)) { |
139 | new_state |= FAILURE_HIGH_OVERTEMP; |
140 | if ((failure_state & FAILURE_HIGH_OVERTEMP) == 0) |
141 | printk(KERN_ERR "windfarm: Critical overtemp due to" |
142 | " immediate CPU temperature !\n" ); |
143 | } |
144 | |
145 | /* |
146 | * The first time around, initialize the array with the first |
147 | * temperature reading |
148 | */ |
149 | if (first) { |
150 | int i; |
151 | |
152 | cpu_thist_total = 0; |
153 | for (i = 0; i < CPU_TEMP_HIST_SIZE; i++) { |
154 | cpu_thist[i] = temp; |
155 | cpu_thist_total += temp; |
156 | } |
157 | first = false; |
158 | } |
159 | |
160 | /* |
161 | * We calculate a history of max temperatures and use that for the |
162 | * overtemp management |
163 | */ |
164 | t_old = cpu_thist[cpu_thist_pt]; |
165 | cpu_thist[cpu_thist_pt] = temp; |
166 | cpu_thist_pt = (cpu_thist_pt + 1) % CPU_TEMP_HIST_SIZE; |
167 | cpu_thist_total -= t_old; |
168 | cpu_thist_total += temp; |
169 | t_avg = cpu_thist_total / CPU_TEMP_HIST_SIZE; |
170 | |
171 | DBG_LOTS(" t_avg = %d.%03d (out: %d.%03d, in: %d.%03d)\n" , |
172 | FIX32TOPRINT(t_avg), FIX32TOPRINT(t_old), FIX32TOPRINT(temp)); |
173 | |
174 | /* Now check for average overtemps */ |
175 | if (t_avg >= (cpu_all_tmax + LOW_OVER_AVERAGE)) { |
176 | new_state |= FAILURE_LOW_OVERTEMP; |
177 | if ((failure_state & FAILURE_LOW_OVERTEMP) == 0) |
178 | printk(KERN_ERR "windfarm: Overtemp due to average CPU" |
179 | " temperature !\n" ); |
180 | } |
181 | if (t_avg >= (cpu_all_tmax + HIGH_OVER_AVERAGE)) { |
182 | new_state |= FAILURE_HIGH_OVERTEMP; |
183 | if ((failure_state & FAILURE_HIGH_OVERTEMP) == 0) |
184 | printk(KERN_ERR "windfarm: Critical overtemp due to" |
185 | " average CPU temperature !\n" ); |
186 | } |
187 | |
188 | /* Now handle overtemp conditions. We don't currently use the windfarm |
189 | * overtemp handling core as it's not fully suited to the needs of those |
190 | * new machine. This will be fixed later. |
191 | */ |
192 | if (new_state) { |
193 | /* High overtemp -> immediate shutdown */ |
194 | if (new_state & FAILURE_HIGH_OVERTEMP) |
195 | machine_power_off(); |
196 | if ((failure_state & new_state) != new_state) |
197 | cpu_max_all_fans(); |
198 | failure_state |= new_state; |
199 | } else if ((failure_state & FAILURE_LOW_OVERTEMP) && |
200 | (temp < (cpu_all_tmax + LOW_OVER_CLEAR))) { |
201 | printk(KERN_ERR "windfarm: Overtemp condition cleared !\n" ); |
202 | failure_state &= ~FAILURE_LOW_OVERTEMP; |
203 | } |
204 | |
205 | return failure_state & (FAILURE_LOW_OVERTEMP | FAILURE_HIGH_OVERTEMP); |
206 | } |
207 | |
208 | static int read_one_cpu_vals(int cpu, s32 *temp, s32 *power) |
209 | { |
210 | s32 dtemp, volts, amps; |
211 | int rc; |
212 | |
213 | /* Get diode temperature */ |
214 | rc = wf_sensor_get(sr: sens_cpu_temp[cpu], val: &dtemp); |
215 | if (rc) { |
216 | DBG(" CPU%d: temp reading error !\n" , cpu); |
217 | return -EIO; |
218 | } |
219 | DBG_LOTS(" CPU%d: temp = %d.%03d\n" , cpu, FIX32TOPRINT((dtemp))); |
220 | *temp = dtemp; |
221 | |
222 | /* Get voltage */ |
223 | rc = wf_sensor_get(sr: sens_cpu_volts[cpu], val: &volts); |
224 | if (rc) { |
225 | DBG(" CPU%d, volts reading error !\n" , cpu); |
226 | return -EIO; |
227 | } |
228 | DBG_LOTS(" CPU%d: volts = %d.%03d\n" , cpu, FIX32TOPRINT((volts))); |
229 | |
230 | /* Get current */ |
231 | rc = wf_sensor_get(sr: sens_cpu_amps[cpu], val: &s); |
232 | if (rc) { |
233 | DBG(" CPU%d, current reading error !\n" , cpu); |
234 | return -EIO; |
235 | } |
236 | DBG_LOTS(" CPU%d: amps = %d.%03d\n" , cpu, FIX32TOPRINT((amps))); |
237 | |
238 | /* Calculate power */ |
239 | |
240 | /* Scale voltage and current raw sensor values according to fixed scales |
241 | * obtained in Darwin and calculate power from I and V |
242 | */ |
243 | *power = (((u64)volts) * ((u64)amps)) >> 16; |
244 | |
245 | DBG_LOTS(" CPU%d: power = %d.%03d\n" , cpu, FIX32TOPRINT((*power))); |
246 | |
247 | return 0; |
248 | |
249 | } |
250 | |
251 | static void cpu_fans_tick_split(void) |
252 | { |
253 | int err, cpu; |
254 | s32 intake, temp, power, t_max = 0; |
255 | |
256 | DBG_LOTS("* cpu fans_tick_split()\n" ); |
257 | |
258 | for (cpu = 0; cpu < nr_chips; ++cpu) { |
259 | struct wf_cpu_pid_state *sp = &cpu_pid[cpu]; |
260 | |
261 | /* Read current speed */ |
262 | wf_control_get(ct: cpu_rear_fans[cpu], val: &sp->target); |
263 | |
264 | DBG_LOTS(" CPU%d: cur_target = %d RPM\n" , cpu, sp->target); |
265 | |
266 | err = read_one_cpu_vals(cpu, temp: &temp, power: &power); |
267 | if (err) { |
268 | failure_state |= FAILURE_SENSOR; |
269 | cpu_max_all_fans(); |
270 | return; |
271 | } |
272 | |
273 | /* Keep track of highest temp */ |
274 | t_max = max(t_max, temp); |
275 | |
276 | /* Handle possible overtemps */ |
277 | if (cpu_check_overtemp(temp: t_max)) |
278 | return; |
279 | |
280 | /* Run PID */ |
281 | wf_cpu_pid_run(st: sp, power, temp); |
282 | |
283 | DBG_LOTS(" CPU%d: target = %d RPM\n" , cpu, sp->target); |
284 | |
285 | /* Apply result directly to exhaust fan */ |
286 | err = wf_control_set(ct: cpu_rear_fans[cpu], val: sp->target); |
287 | if (err) { |
288 | pr_warn("wf_pm72: Fan %s reports error %d\n" , |
289 | cpu_rear_fans[cpu]->name, err); |
290 | failure_state |= FAILURE_FAN; |
291 | break; |
292 | } |
293 | |
294 | /* Scale result for intake fan */ |
295 | intake = (sp->target * CPU_INTAKE_SCALE) >> 16; |
296 | DBG_LOTS(" CPU%d: intake = %d RPM\n" , cpu, intake); |
297 | err = wf_control_set(ct: cpu_front_fans[cpu], val: intake); |
298 | if (err) { |
299 | pr_warn("wf_pm72: Fan %s reports error %d\n" , |
300 | cpu_front_fans[cpu]->name, err); |
301 | failure_state |= FAILURE_FAN; |
302 | break; |
303 | } |
304 | } |
305 | } |
306 | |
307 | static void cpu_fans_tick_combined(void) |
308 | { |
309 | s32 temp0, power0, temp1, power1, t_max = 0; |
310 | s32 temp, power, intake, pump; |
311 | struct wf_control *pump0, *pump1; |
312 | struct wf_cpu_pid_state *sp = &cpu_pid[0]; |
313 | int err, cpu; |
314 | |
315 | DBG_LOTS("* cpu fans_tick_combined()\n" ); |
316 | |
317 | /* Read current speed from cpu 0 */ |
318 | wf_control_get(ct: cpu_rear_fans[0], val: &sp->target); |
319 | |
320 | DBG_LOTS(" CPUs: cur_target = %d RPM\n" , sp->target); |
321 | |
322 | /* Read values for both CPUs */ |
323 | err = read_one_cpu_vals(cpu: 0, temp: &temp0, power: &power0); |
324 | if (err) { |
325 | failure_state |= FAILURE_SENSOR; |
326 | cpu_max_all_fans(); |
327 | return; |
328 | } |
329 | err = read_one_cpu_vals(cpu: 1, temp: &temp1, power: &power1); |
330 | if (err) { |
331 | failure_state |= FAILURE_SENSOR; |
332 | cpu_max_all_fans(); |
333 | return; |
334 | } |
335 | |
336 | /* Keep track of highest temp */ |
337 | t_max = max(t_max, max(temp0, temp1)); |
338 | |
339 | /* Handle possible overtemps */ |
340 | if (cpu_check_overtemp(temp: t_max)) |
341 | return; |
342 | |
343 | /* Use the max temp & power of both */ |
344 | temp = max(temp0, temp1); |
345 | power = max(power0, power1); |
346 | |
347 | /* Run PID */ |
348 | wf_cpu_pid_run(st: sp, power, temp); |
349 | |
350 | /* Scale result for intake fan */ |
351 | intake = (sp->target * CPU_INTAKE_SCALE) >> 16; |
352 | |
353 | /* Same deal with pump speed */ |
354 | pump0 = cpu_pumps[0]; |
355 | pump1 = cpu_pumps[1]; |
356 | if (!pump0) { |
357 | pump0 = pump1; |
358 | pump1 = NULL; |
359 | } |
360 | pump = (sp->target * wf_control_get_max(ct: pump0)) / |
361 | cpu_mpu_data[0]->rmaxn_exhaust_fan; |
362 | |
363 | DBG_LOTS(" CPUs: target = %d RPM\n" , sp->target); |
364 | DBG_LOTS(" CPUs: intake = %d RPM\n" , intake); |
365 | DBG_LOTS(" CPUs: pump = %d RPM\n" , pump); |
366 | |
367 | for (cpu = 0; cpu < nr_chips; cpu++) { |
368 | err = wf_control_set(ct: cpu_rear_fans[cpu], val: sp->target); |
369 | if (err) { |
370 | pr_warn("wf_pm72: Fan %s reports error %d\n" , |
371 | cpu_rear_fans[cpu]->name, err); |
372 | failure_state |= FAILURE_FAN; |
373 | } |
374 | err = wf_control_set(ct: cpu_front_fans[cpu], val: intake); |
375 | if (err) { |
376 | pr_warn("wf_pm72: Fan %s reports error %d\n" , |
377 | cpu_front_fans[cpu]->name, err); |
378 | failure_state |= FAILURE_FAN; |
379 | } |
380 | err = 0; |
381 | if (cpu_pumps[cpu]) |
382 | err = wf_control_set(ct: cpu_pumps[cpu], val: pump); |
383 | if (err) { |
384 | pr_warn("wf_pm72: Pump %s reports error %d\n" , |
385 | cpu_pumps[cpu]->name, err); |
386 | failure_state |= FAILURE_FAN; |
387 | } |
388 | } |
389 | } |
390 | |
391 | /* Implementation... */ |
392 | static int cpu_setup_pid(int cpu) |
393 | { |
394 | struct wf_cpu_pid_param pid; |
395 | const struct mpu_data *mpu = cpu_mpu_data[cpu]; |
396 | s32 tmax, ttarget, ptarget; |
397 | int fmin, fmax, hsize; |
398 | |
399 | /* Get PID params from the appropriate MPU EEPROM */ |
400 | tmax = mpu->tmax << 16; |
401 | ttarget = mpu->ttarget << 16; |
402 | ptarget = ((s32)(mpu->pmaxh - mpu->padjmax)) << 16; |
403 | |
404 | DBG("wf_72: CPU%d ttarget = %d.%03d, tmax = %d.%03d\n" , |
405 | cpu, FIX32TOPRINT(ttarget), FIX32TOPRINT(tmax)); |
406 | |
407 | /* We keep a global tmax for overtemp calculations */ |
408 | if (tmax < cpu_all_tmax) |
409 | cpu_all_tmax = tmax; |
410 | |
411 | /* Set PID min/max by using the rear fan min/max */ |
412 | fmin = wf_control_get_min(ct: cpu_rear_fans[cpu]); |
413 | fmax = wf_control_get_max(ct: cpu_rear_fans[cpu]); |
414 | DBG("wf_72: CPU%d max RPM range = [%d..%d]\n" , cpu, fmin, fmax); |
415 | |
416 | /* History size */ |
417 | hsize = min_t(int, mpu->tguardband, WF_PID_MAX_HISTORY); |
418 | DBG("wf_72: CPU%d history size = %d\n" , cpu, hsize); |
419 | |
420 | /* Initialize PID loop */ |
421 | pid.interval = 1; /* seconds */ |
422 | pid.history_len = hsize; |
423 | pid.gd = mpu->pid_gd; |
424 | pid.gp = mpu->pid_gp; |
425 | pid.gr = mpu->pid_gr; |
426 | pid.tmax = tmax; |
427 | pid.ttarget = ttarget; |
428 | pid.pmaxadj = ptarget; |
429 | pid.min = fmin; |
430 | pid.max = fmax; |
431 | |
432 | wf_cpu_pid_init(st: &cpu_pid[cpu], param: &pid); |
433 | cpu_pid[cpu].target = 1000; |
434 | |
435 | return 0; |
436 | } |
437 | |
438 | /* Backside/U3 fan */ |
439 | static struct wf_pid_param backside_u3_param = { |
440 | .interval = 5, |
441 | .history_len = 2, |
442 | .gd = 40 << 20, |
443 | .gp = 5 << 20, |
444 | .gr = 0, |
445 | .itarget = 65 << 16, |
446 | .additive = 1, |
447 | .min = 20, |
448 | .max = 100, |
449 | }; |
450 | |
451 | static struct wf_pid_param backside_u3h_param = { |
452 | .interval = 5, |
453 | .history_len = 2, |
454 | .gd = 20 << 20, |
455 | .gp = 5 << 20, |
456 | .gr = 0, |
457 | .itarget = 75 << 16, |
458 | .additive = 1, |
459 | .min = 20, |
460 | .max = 100, |
461 | }; |
462 | |
463 | static void backside_fan_tick(void) |
464 | { |
465 | s32 temp; |
466 | int speed; |
467 | int err; |
468 | |
469 | if (!backside_fan || !backside_temp || !backside_tick) |
470 | return; |
471 | if (--backside_tick > 0) |
472 | return; |
473 | backside_tick = backside_pid.param.interval; |
474 | |
475 | DBG_LOTS("* backside fans tick\n" ); |
476 | |
477 | /* Update fan speed from actual fans */ |
478 | err = wf_control_get(ct: backside_fan, val: &speed); |
479 | if (!err) |
480 | backside_pid.target = speed; |
481 | |
482 | err = wf_sensor_get(sr: backside_temp, val: &temp); |
483 | if (err) { |
484 | printk(KERN_WARNING "windfarm: U4 temp sensor error %d\n" , |
485 | err); |
486 | failure_state |= FAILURE_SENSOR; |
487 | wf_control_set_max(ct: backside_fan); |
488 | return; |
489 | } |
490 | speed = wf_pid_run(st: &backside_pid, sample: temp); |
491 | |
492 | DBG_LOTS("backside PID temp=%d.%.3d speed=%d\n" , |
493 | FIX32TOPRINT(temp), speed); |
494 | |
495 | err = wf_control_set(ct: backside_fan, val: speed); |
496 | if (err) { |
497 | printk(KERN_WARNING "windfarm: backside fan error %d\n" , err); |
498 | failure_state |= FAILURE_FAN; |
499 | } |
500 | } |
501 | |
502 | static void backside_setup_pid(void) |
503 | { |
504 | /* first time initialize things */ |
505 | s32 fmin = wf_control_get_min(ct: backside_fan); |
506 | s32 fmax = wf_control_get_max(ct: backside_fan); |
507 | struct wf_pid_param param; |
508 | struct device_node *u3; |
509 | int u3h = 1; /* conservative by default */ |
510 | |
511 | u3 = of_find_node_by_path(path: "/u3@0,f8000000" ); |
512 | if (u3 != NULL) { |
513 | const u32 *vers = of_get_property(node: u3, name: "device-rev" , NULL); |
514 | if (vers) |
515 | if (((*vers) & 0x3f) < 0x34) |
516 | u3h = 0; |
517 | of_node_put(node: u3); |
518 | } |
519 | |
520 | param = u3h ? backside_u3h_param : backside_u3_param; |
521 | |
522 | param.min = max(param.min, fmin); |
523 | param.max = min(param.max, fmax); |
524 | wf_pid_init(st: &backside_pid, param: ¶m); |
525 | backside_tick = 1; |
526 | |
527 | pr_info("wf_pm72: Backside control loop started.\n" ); |
528 | } |
529 | |
530 | /* Drive bay fan */ |
531 | static const struct wf_pid_param drives_param = { |
532 | .interval = 5, |
533 | .history_len = 2, |
534 | .gd = 30 << 20, |
535 | .gp = 5 << 20, |
536 | .gr = 0, |
537 | .itarget = 40 << 16, |
538 | .additive = 1, |
539 | .min = 300, |
540 | .max = 4000, |
541 | }; |
542 | |
543 | static void drives_fan_tick(void) |
544 | { |
545 | s32 temp; |
546 | int speed; |
547 | int err; |
548 | |
549 | if (!drives_fan || !drives_temp || !drives_tick) |
550 | return; |
551 | if (--drives_tick > 0) |
552 | return; |
553 | drives_tick = drives_pid.param.interval; |
554 | |
555 | DBG_LOTS("* drives fans tick\n" ); |
556 | |
557 | /* Update fan speed from actual fans */ |
558 | err = wf_control_get(ct: drives_fan, val: &speed); |
559 | if (!err) |
560 | drives_pid.target = speed; |
561 | |
562 | err = wf_sensor_get(sr: drives_temp, val: &temp); |
563 | if (err) { |
564 | pr_warn("wf_pm72: drive bay temp sensor error %d\n" , err); |
565 | failure_state |= FAILURE_SENSOR; |
566 | wf_control_set_max(ct: drives_fan); |
567 | return; |
568 | } |
569 | speed = wf_pid_run(st: &drives_pid, sample: temp); |
570 | |
571 | DBG_LOTS("drives PID temp=%d.%.3d speed=%d\n" , |
572 | FIX32TOPRINT(temp), speed); |
573 | |
574 | err = wf_control_set(ct: drives_fan, val: speed); |
575 | if (err) { |
576 | printk(KERN_WARNING "windfarm: drive bay fan error %d\n" , err); |
577 | failure_state |= FAILURE_FAN; |
578 | } |
579 | } |
580 | |
581 | static void drives_setup_pid(void) |
582 | { |
583 | /* first time initialize things */ |
584 | s32 fmin = wf_control_get_min(ct: drives_fan); |
585 | s32 fmax = wf_control_get_max(ct: drives_fan); |
586 | struct wf_pid_param param = drives_param; |
587 | |
588 | param.min = max(param.min, fmin); |
589 | param.max = min(param.max, fmax); |
590 | wf_pid_init(st: &drives_pid, param: ¶m); |
591 | drives_tick = 1; |
592 | |
593 | pr_info("wf_pm72: Drive bay control loop started.\n" ); |
594 | } |
595 | |
596 | static void set_fail_state(void) |
597 | { |
598 | cpu_max_all_fans(); |
599 | |
600 | if (backside_fan) |
601 | wf_control_set_max(ct: backside_fan); |
602 | if (slots_fan) |
603 | wf_control_set_max(ct: slots_fan); |
604 | if (drives_fan) |
605 | wf_control_set_max(ct: drives_fan); |
606 | } |
607 | |
608 | static void pm72_tick(void) |
609 | { |
610 | int i, last_failure; |
611 | |
612 | if (!started) { |
613 | started = true; |
614 | printk(KERN_INFO "windfarm: CPUs control loops started.\n" ); |
615 | for (i = 0; i < nr_chips; ++i) { |
616 | if (cpu_setup_pid(cpu: i) < 0) { |
617 | failure_state = FAILURE_PERM; |
618 | set_fail_state(); |
619 | break; |
620 | } |
621 | } |
622 | DBG_LOTS("cpu_all_tmax=%d.%03d\n" , FIX32TOPRINT(cpu_all_tmax)); |
623 | |
624 | backside_setup_pid(); |
625 | drives_setup_pid(); |
626 | |
627 | /* |
628 | * We don't have the right stuff to drive the PCI fan |
629 | * so we fix it to a default value |
630 | */ |
631 | wf_control_set(ct: slots_fan, SLOTS_FAN_DEFAULT_PWM); |
632 | |
633 | #ifdef HACKED_OVERTEMP |
634 | cpu_all_tmax = 60 << 16; |
635 | #endif |
636 | } |
637 | |
638 | /* Permanent failure, bail out */ |
639 | if (failure_state & FAILURE_PERM) |
640 | return; |
641 | |
642 | /* |
643 | * Clear all failure bits except low overtemp which will be eventually |
644 | * cleared by the control loop itself |
645 | */ |
646 | last_failure = failure_state; |
647 | failure_state &= FAILURE_LOW_OVERTEMP; |
648 | if (cpu_pid_combined) |
649 | cpu_fans_tick_combined(); |
650 | else |
651 | cpu_fans_tick_split(); |
652 | backside_fan_tick(); |
653 | drives_fan_tick(); |
654 | |
655 | DBG_LOTS(" last_failure: 0x%x, failure_state: %x\n" , |
656 | last_failure, failure_state); |
657 | |
658 | /* Check for failures. Any failure causes cpufreq clamping */ |
659 | if (failure_state && last_failure == 0 && cpufreq_clamp) |
660 | wf_control_set_max(ct: cpufreq_clamp); |
661 | if (failure_state == 0 && last_failure && cpufreq_clamp) |
662 | wf_control_set_min(ct: cpufreq_clamp); |
663 | |
664 | /* That's it for now, we might want to deal with other failures |
665 | * differently in the future though |
666 | */ |
667 | } |
668 | |
669 | static void pm72_new_control(struct wf_control *ct) |
670 | { |
671 | bool all_controls; |
672 | bool had_pump = cpu_pumps[0] || cpu_pumps[1]; |
673 | |
674 | if (!strcmp(ct->name, "cpu-front-fan-0" )) |
675 | cpu_front_fans[0] = ct; |
676 | else if (!strcmp(ct->name, "cpu-front-fan-1" )) |
677 | cpu_front_fans[1] = ct; |
678 | else if (!strcmp(ct->name, "cpu-rear-fan-0" )) |
679 | cpu_rear_fans[0] = ct; |
680 | else if (!strcmp(ct->name, "cpu-rear-fan-1" )) |
681 | cpu_rear_fans[1] = ct; |
682 | else if (!strcmp(ct->name, "cpu-pump-0" )) |
683 | cpu_pumps[0] = ct; |
684 | else if (!strcmp(ct->name, "cpu-pump-1" )) |
685 | cpu_pumps[1] = ct; |
686 | else if (!strcmp(ct->name, "backside-fan" )) |
687 | backside_fan = ct; |
688 | else if (!strcmp(ct->name, "slots-fan" )) |
689 | slots_fan = ct; |
690 | else if (!strcmp(ct->name, "drive-bay-fan" )) |
691 | drives_fan = ct; |
692 | else if (!strcmp(ct->name, "cpufreq-clamp" )) |
693 | cpufreq_clamp = ct; |
694 | |
695 | all_controls = |
696 | cpu_front_fans[0] && |
697 | cpu_rear_fans[0] && |
698 | backside_fan && |
699 | slots_fan && |
700 | drives_fan; |
701 | if (nr_chips > 1) |
702 | all_controls &= |
703 | cpu_front_fans[1] && |
704 | cpu_rear_fans[1]; |
705 | have_all_controls = all_controls; |
706 | |
707 | if ((cpu_pumps[0] || cpu_pumps[1]) && !had_pump) { |
708 | pr_info("wf_pm72: Liquid cooling pump(s) detected," |
709 | " using new algorithm !\n" ); |
710 | cpu_pid_combined = true; |
711 | } |
712 | } |
713 | |
714 | |
715 | static void pm72_new_sensor(struct wf_sensor *sr) |
716 | { |
717 | bool all_sensors; |
718 | |
719 | if (!strcmp(sr->name, "cpu-diode-temp-0" )) |
720 | sens_cpu_temp[0] = sr; |
721 | else if (!strcmp(sr->name, "cpu-diode-temp-1" )) |
722 | sens_cpu_temp[1] = sr; |
723 | else if (!strcmp(sr->name, "cpu-voltage-0" )) |
724 | sens_cpu_volts[0] = sr; |
725 | else if (!strcmp(sr->name, "cpu-voltage-1" )) |
726 | sens_cpu_volts[1] = sr; |
727 | else if (!strcmp(sr->name, "cpu-current-0" )) |
728 | sens_cpu_amps[0] = sr; |
729 | else if (!strcmp(sr->name, "cpu-current-1" )) |
730 | sens_cpu_amps[1] = sr; |
731 | else if (!strcmp(sr->name, "backside-temp" )) |
732 | backside_temp = sr; |
733 | else if (!strcmp(sr->name, "hd-temp" )) |
734 | drives_temp = sr; |
735 | |
736 | all_sensors = |
737 | sens_cpu_temp[0] && |
738 | sens_cpu_volts[0] && |
739 | sens_cpu_amps[0] && |
740 | backside_temp && |
741 | drives_temp; |
742 | if (nr_chips > 1) |
743 | all_sensors &= |
744 | sens_cpu_temp[1] && |
745 | sens_cpu_volts[1] && |
746 | sens_cpu_amps[1]; |
747 | |
748 | have_all_sensors = all_sensors; |
749 | } |
750 | |
751 | static int pm72_wf_notify(struct notifier_block *self, |
752 | unsigned long event, void *data) |
753 | { |
754 | switch (event) { |
755 | case WF_EVENT_NEW_SENSOR: |
756 | pm72_new_sensor(sr: data); |
757 | break; |
758 | case WF_EVENT_NEW_CONTROL: |
759 | pm72_new_control(ct: data); |
760 | break; |
761 | case WF_EVENT_TICK: |
762 | if (have_all_controls && have_all_sensors) |
763 | pm72_tick(); |
764 | } |
765 | return 0; |
766 | } |
767 | |
768 | static struct notifier_block pm72_events = { |
769 | .notifier_call = pm72_wf_notify, |
770 | }; |
771 | |
772 | static int wf_pm72_probe(struct platform_device *dev) |
773 | { |
774 | wf_register_client(nb: &pm72_events); |
775 | return 0; |
776 | } |
777 | |
778 | static void wf_pm72_remove(struct platform_device *dev) |
779 | { |
780 | wf_unregister_client(nb: &pm72_events); |
781 | } |
782 | |
783 | static struct platform_driver wf_pm72_driver = { |
784 | .probe = wf_pm72_probe, |
785 | .remove_new = wf_pm72_remove, |
786 | .driver = { |
787 | .name = "windfarm" , |
788 | }, |
789 | }; |
790 | |
791 | static int __init wf_pm72_init(void) |
792 | { |
793 | struct device_node *cpu; |
794 | int i; |
795 | |
796 | if (!of_machine_is_compatible(compat: "PowerMac7,2" ) && |
797 | !of_machine_is_compatible(compat: "PowerMac7,3" )) |
798 | return -ENODEV; |
799 | |
800 | /* Count the number of CPU cores */ |
801 | nr_chips = 0; |
802 | for_each_node_by_type(cpu, "cpu" ) |
803 | ++nr_chips; |
804 | if (nr_chips > NR_CHIPS) |
805 | nr_chips = NR_CHIPS; |
806 | |
807 | pr_info("windfarm: Initializing for desktop G5 with %d chips\n" , |
808 | nr_chips); |
809 | |
810 | /* Get MPU data for each CPU */ |
811 | for (i = 0; i < nr_chips; i++) { |
812 | cpu_mpu_data[i] = wf_get_mpu(cpu: i); |
813 | if (!cpu_mpu_data[i]) { |
814 | pr_err("wf_pm72: Failed to find MPU data for CPU %d\n" , i); |
815 | return -ENXIO; |
816 | } |
817 | } |
818 | |
819 | #ifdef MODULE |
820 | request_module("windfarm_fcu_controls" ); |
821 | request_module("windfarm_lm75_sensor" ); |
822 | request_module("windfarm_ad7417_sensor" ); |
823 | request_module("windfarm_max6690_sensor" ); |
824 | request_module("windfarm_cpufreq_clamp" ); |
825 | #endif /* MODULE */ |
826 | |
827 | platform_driver_register(&wf_pm72_driver); |
828 | return 0; |
829 | } |
830 | |
831 | static void __exit wf_pm72_exit(void) |
832 | { |
833 | platform_driver_unregister(&wf_pm72_driver); |
834 | } |
835 | |
836 | module_init(wf_pm72_init); |
837 | module_exit(wf_pm72_exit); |
838 | |
839 | MODULE_AUTHOR("Benjamin Herrenschmidt <benh@kernel.crashing.org>" ); |
840 | MODULE_DESCRIPTION("Thermal control for AGP PowerMac G5s" ); |
841 | MODULE_LICENSE("GPL" ); |
842 | MODULE_ALIAS("platform:windfarm" ); |
843 | |