1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* |
3 | * Windfarm PowerMac thermal control. |
4 | * Control loops for RackMack3,1 (Xserve G5) |
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 *slots_temp; |
53 | static struct wf_sensor *dimms_temp; |
54 | |
55 | static struct wf_control *cpu_fans[NR_CHIPS][3]; |
56 | static struct wf_control *backside_fan; |
57 | static struct wf_control *slots_fan; |
58 | static struct wf_control *cpufreq_clamp; |
59 | |
60 | /* We keep a temperature history for average calculation of 180s */ |
61 | #define CPU_TEMP_HIST_SIZE 180 |
62 | |
63 | /* PID loop state */ |
64 | static const struct mpu_data *cpu_mpu_data[NR_CHIPS]; |
65 | static struct wf_cpu_pid_state cpu_pid[NR_CHIPS]; |
66 | static u32 cpu_thist[CPU_TEMP_HIST_SIZE]; |
67 | static int cpu_thist_pt; |
68 | static s64 cpu_thist_total; |
69 | static s32 cpu_all_tmax = 100 << 16; |
70 | static struct wf_pid_state backside_pid; |
71 | static int backside_tick; |
72 | static struct wf_pid_state slots_pid; |
73 | static int slots_tick; |
74 | static int slots_speed; |
75 | static struct wf_pid_state dimms_pid; |
76 | static int dimms_output_clamp; |
77 | |
78 | static int nr_chips; |
79 | static bool have_all_controls; |
80 | static bool have_all_sensors; |
81 | static bool started; |
82 | |
83 | static int failure_state; |
84 | #define FAILURE_SENSOR 1 |
85 | #define FAILURE_FAN 2 |
86 | #define FAILURE_PERM 4 |
87 | #define FAILURE_LOW_OVERTEMP 8 |
88 | #define FAILURE_HIGH_OVERTEMP 16 |
89 | |
90 | /* Overtemp values */ |
91 | #define LOW_OVER_AVERAGE 0 |
92 | #define LOW_OVER_IMMEDIATE (10 << 16) |
93 | #define LOW_OVER_CLEAR ((-10) << 16) |
94 | #define HIGH_OVER_IMMEDIATE (14 << 16) |
95 | #define HIGH_OVER_AVERAGE (10 << 16) |
96 | #define HIGH_OVER_IMMEDIATE (14 << 16) |
97 | |
98 | |
99 | static void cpu_max_all_fans(void) |
100 | { |
101 | int i; |
102 | |
103 | /* We max all CPU fans in case of a sensor error. We also do the |
104 | * cpufreq clamping now, even if it's supposedly done later by the |
105 | * generic code anyway, we do it earlier here to react faster |
106 | */ |
107 | if (cpufreq_clamp) |
108 | wf_control_set_max(ct: cpufreq_clamp); |
109 | for (i = 0; i < nr_chips; i++) { |
110 | if (cpu_fans[i][0]) |
111 | wf_control_set_max(ct: cpu_fans[i][0]); |
112 | if (cpu_fans[i][1]) |
113 | wf_control_set_max(ct: cpu_fans[i][1]); |
114 | if (cpu_fans[i][2]) |
115 | wf_control_set_max(ct: cpu_fans[i][2]); |
116 | } |
117 | } |
118 | |
119 | static int cpu_check_overtemp(s32 temp) |
120 | { |
121 | int new_state = 0; |
122 | s32 t_avg, t_old; |
123 | static bool first = true; |
124 | |
125 | /* First check for immediate overtemps */ |
126 | if (temp >= (cpu_all_tmax + LOW_OVER_IMMEDIATE)) { |
127 | new_state |= FAILURE_LOW_OVERTEMP; |
128 | if ((failure_state & FAILURE_LOW_OVERTEMP) == 0) |
129 | printk(KERN_ERR "windfarm: Overtemp due to immediate CPU" |
130 | " temperature !\n" ); |
131 | } |
132 | if (temp >= (cpu_all_tmax + HIGH_OVER_IMMEDIATE)) { |
133 | new_state |= FAILURE_HIGH_OVERTEMP; |
134 | if ((failure_state & FAILURE_HIGH_OVERTEMP) == 0) |
135 | printk(KERN_ERR "windfarm: Critical overtemp due to" |
136 | " immediate CPU temperature !\n" ); |
137 | } |
138 | |
139 | /* |
140 | * The first time around, initialize the array with the first |
141 | * temperature reading |
142 | */ |
143 | if (first) { |
144 | int i; |
145 | |
146 | cpu_thist_total = 0; |
147 | for (i = 0; i < CPU_TEMP_HIST_SIZE; i++) { |
148 | cpu_thist[i] = temp; |
149 | cpu_thist_total += temp; |
150 | } |
151 | first = false; |
152 | } |
153 | |
154 | /* |
155 | * We calculate a history of max temperatures and use that for the |
156 | * overtemp management |
157 | */ |
158 | t_old = cpu_thist[cpu_thist_pt]; |
159 | cpu_thist[cpu_thist_pt] = temp; |
160 | cpu_thist_pt = (cpu_thist_pt + 1) % CPU_TEMP_HIST_SIZE; |
161 | cpu_thist_total -= t_old; |
162 | cpu_thist_total += temp; |
163 | t_avg = cpu_thist_total / CPU_TEMP_HIST_SIZE; |
164 | |
165 | DBG_LOTS(" t_avg = %d.%03d (out: %d.%03d, in: %d.%03d)\n" , |
166 | FIX32TOPRINT(t_avg), FIX32TOPRINT(t_old), FIX32TOPRINT(temp)); |
167 | |
168 | /* Now check for average overtemps */ |
169 | if (t_avg >= (cpu_all_tmax + LOW_OVER_AVERAGE)) { |
170 | new_state |= FAILURE_LOW_OVERTEMP; |
171 | if ((failure_state & FAILURE_LOW_OVERTEMP) == 0) |
172 | printk(KERN_ERR "windfarm: Overtemp due to average CPU" |
173 | " temperature !\n" ); |
174 | } |
175 | if (t_avg >= (cpu_all_tmax + HIGH_OVER_AVERAGE)) { |
176 | new_state |= FAILURE_HIGH_OVERTEMP; |
177 | if ((failure_state & FAILURE_HIGH_OVERTEMP) == 0) |
178 | printk(KERN_ERR "windfarm: Critical overtemp due to" |
179 | " average CPU temperature !\n" ); |
180 | } |
181 | |
182 | /* Now handle overtemp conditions. We don't currently use the windfarm |
183 | * overtemp handling core as it's not fully suited to the needs of those |
184 | * new machine. This will be fixed later. |
185 | */ |
186 | if (new_state) { |
187 | /* High overtemp -> immediate shutdown */ |
188 | if (new_state & FAILURE_HIGH_OVERTEMP) |
189 | machine_power_off(); |
190 | if ((failure_state & new_state) != new_state) |
191 | cpu_max_all_fans(); |
192 | failure_state |= new_state; |
193 | } else if ((failure_state & FAILURE_LOW_OVERTEMP) && |
194 | (temp < (cpu_all_tmax + LOW_OVER_CLEAR))) { |
195 | printk(KERN_ERR "windfarm: Overtemp condition cleared !\n" ); |
196 | failure_state &= ~FAILURE_LOW_OVERTEMP; |
197 | } |
198 | |
199 | return failure_state & (FAILURE_LOW_OVERTEMP | FAILURE_HIGH_OVERTEMP); |
200 | } |
201 | |
202 | static int read_one_cpu_vals(int cpu, s32 *temp, s32 *power) |
203 | { |
204 | s32 dtemp, volts, amps; |
205 | int rc; |
206 | |
207 | /* Get diode temperature */ |
208 | rc = wf_sensor_get(sr: sens_cpu_temp[cpu], val: &dtemp); |
209 | if (rc) { |
210 | DBG(" CPU%d: temp reading error !\n" , cpu); |
211 | return -EIO; |
212 | } |
213 | DBG_LOTS(" CPU%d: temp = %d.%03d\n" , cpu, FIX32TOPRINT((dtemp))); |
214 | *temp = dtemp; |
215 | |
216 | /* Get voltage */ |
217 | rc = wf_sensor_get(sr: sens_cpu_volts[cpu], val: &volts); |
218 | if (rc) { |
219 | DBG(" CPU%d, volts reading error !\n" , cpu); |
220 | return -EIO; |
221 | } |
222 | DBG_LOTS(" CPU%d: volts = %d.%03d\n" , cpu, FIX32TOPRINT((volts))); |
223 | |
224 | /* Get current */ |
225 | rc = wf_sensor_get(sr: sens_cpu_amps[cpu], val: &s); |
226 | if (rc) { |
227 | DBG(" CPU%d, current reading error !\n" , cpu); |
228 | return -EIO; |
229 | } |
230 | DBG_LOTS(" CPU%d: amps = %d.%03d\n" , cpu, FIX32TOPRINT((amps))); |
231 | |
232 | /* Calculate power */ |
233 | |
234 | /* Scale voltage and current raw sensor values according to fixed scales |
235 | * obtained in Darwin and calculate power from I and V |
236 | */ |
237 | *power = (((u64)volts) * ((u64)amps)) >> 16; |
238 | |
239 | DBG_LOTS(" CPU%d: power = %d.%03d\n" , cpu, FIX32TOPRINT((*power))); |
240 | |
241 | return 0; |
242 | |
243 | } |
244 | |
245 | static void cpu_fans_tick(void) |
246 | { |
247 | int err, cpu, i; |
248 | s32 speed, temp, power, t_max = 0; |
249 | |
250 | DBG_LOTS("* cpu fans_tick_split()\n" ); |
251 | |
252 | for (cpu = 0; cpu < nr_chips; ++cpu) { |
253 | struct wf_cpu_pid_state *sp = &cpu_pid[cpu]; |
254 | |
255 | /* Read current speed */ |
256 | wf_control_get(ct: cpu_fans[cpu][0], val: &sp->target); |
257 | |
258 | err = read_one_cpu_vals(cpu, temp: &temp, power: &power); |
259 | if (err) { |
260 | failure_state |= FAILURE_SENSOR; |
261 | cpu_max_all_fans(); |
262 | return; |
263 | } |
264 | |
265 | /* Keep track of highest temp */ |
266 | t_max = max(t_max, temp); |
267 | |
268 | /* Handle possible overtemps */ |
269 | if (cpu_check_overtemp(temp: t_max)) |
270 | return; |
271 | |
272 | /* Run PID */ |
273 | wf_cpu_pid_run(st: sp, power, temp); |
274 | |
275 | DBG_LOTS(" CPU%d: target = %d RPM\n" , cpu, sp->target); |
276 | |
277 | /* Apply DIMMs clamp */ |
278 | speed = max(sp->target, dimms_output_clamp); |
279 | |
280 | /* Apply result to all cpu fans */ |
281 | for (i = 0; i < 3; i++) { |
282 | err = wf_control_set(ct: cpu_fans[cpu][i], val: speed); |
283 | if (err) { |
284 | pr_warn("wf_rm31: Fan %s reports error %d\n" , |
285 | cpu_fans[cpu][i]->name, err); |
286 | failure_state |= FAILURE_FAN; |
287 | } |
288 | } |
289 | } |
290 | } |
291 | |
292 | /* Implementation... */ |
293 | static int cpu_setup_pid(int cpu) |
294 | { |
295 | struct wf_cpu_pid_param pid; |
296 | const struct mpu_data *mpu = cpu_mpu_data[cpu]; |
297 | s32 tmax, ttarget, ptarget; |
298 | int fmin, fmax, hsize; |
299 | |
300 | /* Get PID params from the appropriate MPU EEPROM */ |
301 | tmax = mpu->tmax << 16; |
302 | ttarget = mpu->ttarget << 16; |
303 | ptarget = ((s32)(mpu->pmaxh - mpu->padjmax)) << 16; |
304 | |
305 | DBG("wf_72: CPU%d ttarget = %d.%03d, tmax = %d.%03d\n" , |
306 | cpu, FIX32TOPRINT(ttarget), FIX32TOPRINT(tmax)); |
307 | |
308 | /* We keep a global tmax for overtemp calculations */ |
309 | if (tmax < cpu_all_tmax) |
310 | cpu_all_tmax = tmax; |
311 | |
312 | /* Set PID min/max by using the rear fan min/max */ |
313 | fmin = wf_control_get_min(ct: cpu_fans[cpu][0]); |
314 | fmax = wf_control_get_max(ct: cpu_fans[cpu][0]); |
315 | DBG("wf_72: CPU%d max RPM range = [%d..%d]\n" , cpu, fmin, fmax); |
316 | |
317 | /* History size */ |
318 | hsize = min_t(int, mpu->tguardband, WF_PID_MAX_HISTORY); |
319 | DBG("wf_72: CPU%d history size = %d\n" , cpu, hsize); |
320 | |
321 | /* Initialize PID loop */ |
322 | pid.interval = 1; /* seconds */ |
323 | pid.history_len = hsize; |
324 | pid.gd = mpu->pid_gd; |
325 | pid.gp = mpu->pid_gp; |
326 | pid.gr = mpu->pid_gr; |
327 | pid.tmax = tmax; |
328 | pid.ttarget = ttarget; |
329 | pid.pmaxadj = ptarget; |
330 | pid.min = fmin; |
331 | pid.max = fmax; |
332 | |
333 | wf_cpu_pid_init(st: &cpu_pid[cpu], param: &pid); |
334 | cpu_pid[cpu].target = 4000; |
335 | |
336 | return 0; |
337 | } |
338 | |
339 | /* Backside/U3 fan */ |
340 | static const struct wf_pid_param backside_param = { |
341 | .interval = 1, |
342 | .history_len = 2, |
343 | .gd = 0x00500000, |
344 | .gp = 0x0004cccc, |
345 | .gr = 0, |
346 | .itarget = 70 << 16, |
347 | .additive = 0, |
348 | .min = 20, |
349 | .max = 100, |
350 | }; |
351 | |
352 | /* DIMMs temperature (clamp the backside fan) */ |
353 | static const struct wf_pid_param dimms_param = { |
354 | .interval = 1, |
355 | .history_len = 20, |
356 | .gd = 0, |
357 | .gp = 0, |
358 | .gr = 0x06553600, |
359 | .itarget = 50 << 16, |
360 | .additive = 0, |
361 | .min = 4000, |
362 | .max = 14000, |
363 | }; |
364 | |
365 | static void backside_fan_tick(void) |
366 | { |
367 | s32 temp, dtemp; |
368 | int speed, dspeed, fan_min; |
369 | int err; |
370 | |
371 | if (!backside_fan || !backside_temp || !dimms_temp || !backside_tick) |
372 | return; |
373 | if (--backside_tick > 0) |
374 | return; |
375 | backside_tick = backside_pid.param.interval; |
376 | |
377 | DBG_LOTS("* backside fans tick\n" ); |
378 | |
379 | /* Update fan speed from actual fans */ |
380 | err = wf_control_get(ct: backside_fan, val: &speed); |
381 | if (!err) |
382 | backside_pid.target = speed; |
383 | |
384 | err = wf_sensor_get(sr: backside_temp, val: &temp); |
385 | if (err) { |
386 | printk(KERN_WARNING "windfarm: U3 temp sensor error %d\n" , |
387 | err); |
388 | failure_state |= FAILURE_SENSOR; |
389 | wf_control_set_max(ct: backside_fan); |
390 | return; |
391 | } |
392 | speed = wf_pid_run(st: &backside_pid, sample: temp); |
393 | |
394 | DBG_LOTS("backside PID temp=%d.%.3d speed=%d\n" , |
395 | FIX32TOPRINT(temp), speed); |
396 | |
397 | err = wf_sensor_get(sr: dimms_temp, val: &dtemp); |
398 | if (err) { |
399 | printk(KERN_WARNING "windfarm: DIMMs temp sensor error %d\n" , |
400 | err); |
401 | failure_state |= FAILURE_SENSOR; |
402 | wf_control_set_max(ct: backside_fan); |
403 | return; |
404 | } |
405 | dspeed = wf_pid_run(st: &dimms_pid, sample: dtemp); |
406 | dimms_output_clamp = dspeed; |
407 | |
408 | fan_min = (dspeed * 100) / 14000; |
409 | fan_min = max(fan_min, backside_param.min); |
410 | speed = max(speed, fan_min); |
411 | |
412 | err = wf_control_set(ct: backside_fan, val: speed); |
413 | if (err) { |
414 | printk(KERN_WARNING "windfarm: backside fan error %d\n" , err); |
415 | failure_state |= FAILURE_FAN; |
416 | } |
417 | } |
418 | |
419 | static void backside_setup_pid(void) |
420 | { |
421 | /* first time initialize things */ |
422 | s32 fmin = wf_control_get_min(ct: backside_fan); |
423 | s32 fmax = wf_control_get_max(ct: backside_fan); |
424 | struct wf_pid_param param; |
425 | |
426 | param = backside_param; |
427 | param.min = max(param.min, fmin); |
428 | param.max = min(param.max, fmax); |
429 | wf_pid_init(st: &backside_pid, param: ¶m); |
430 | |
431 | param = dimms_param; |
432 | wf_pid_init(st: &dimms_pid, param: ¶m); |
433 | |
434 | backside_tick = 1; |
435 | |
436 | pr_info("wf_rm31: Backside control loop started.\n" ); |
437 | } |
438 | |
439 | /* Slots fan */ |
440 | static const struct wf_pid_param slots_param = { |
441 | .interval = 1, |
442 | .history_len = 20, |
443 | .gd = 0, |
444 | .gp = 0, |
445 | .gr = 0x00100000, |
446 | .itarget = 3200000, |
447 | .additive = 0, |
448 | .min = 20, |
449 | .max = 100, |
450 | }; |
451 | |
452 | static void slots_fan_tick(void) |
453 | { |
454 | s32 temp; |
455 | int speed; |
456 | int err; |
457 | |
458 | if (!slots_fan || !slots_temp || !slots_tick) |
459 | return; |
460 | if (--slots_tick > 0) |
461 | return; |
462 | slots_tick = slots_pid.param.interval; |
463 | |
464 | DBG_LOTS("* slots fans tick\n" ); |
465 | |
466 | err = wf_sensor_get(sr: slots_temp, val: &temp); |
467 | if (err) { |
468 | pr_warn("wf_rm31: slots temp sensor error %d\n" , err); |
469 | failure_state |= FAILURE_SENSOR; |
470 | wf_control_set_max(ct: slots_fan); |
471 | return; |
472 | } |
473 | speed = wf_pid_run(st: &slots_pid, sample: temp); |
474 | |
475 | DBG_LOTS("slots PID temp=%d.%.3d speed=%d\n" , |
476 | FIX32TOPRINT(temp), speed); |
477 | |
478 | slots_speed = speed; |
479 | err = wf_control_set(ct: slots_fan, val: speed); |
480 | if (err) { |
481 | printk(KERN_WARNING "windfarm: slots bay fan error %d\n" , err); |
482 | failure_state |= FAILURE_FAN; |
483 | } |
484 | } |
485 | |
486 | static void slots_setup_pid(void) |
487 | { |
488 | /* first time initialize things */ |
489 | s32 fmin = wf_control_get_min(ct: slots_fan); |
490 | s32 fmax = wf_control_get_max(ct: slots_fan); |
491 | struct wf_pid_param param = slots_param; |
492 | |
493 | param.min = max(param.min, fmin); |
494 | param.max = min(param.max, fmax); |
495 | wf_pid_init(st: &slots_pid, param: ¶m); |
496 | slots_tick = 1; |
497 | |
498 | pr_info("wf_rm31: Slots control loop started.\n" ); |
499 | } |
500 | |
501 | static void set_fail_state(void) |
502 | { |
503 | cpu_max_all_fans(); |
504 | |
505 | if (backside_fan) |
506 | wf_control_set_max(ct: backside_fan); |
507 | if (slots_fan) |
508 | wf_control_set_max(ct: slots_fan); |
509 | } |
510 | |
511 | static void rm31_tick(void) |
512 | { |
513 | int i, last_failure; |
514 | |
515 | if (!started) { |
516 | started = true; |
517 | printk(KERN_INFO "windfarm: CPUs control loops started.\n" ); |
518 | for (i = 0; i < nr_chips; ++i) { |
519 | if (cpu_setup_pid(cpu: i) < 0) { |
520 | failure_state = FAILURE_PERM; |
521 | set_fail_state(); |
522 | break; |
523 | } |
524 | } |
525 | DBG_LOTS("cpu_all_tmax=%d.%03d\n" , FIX32TOPRINT(cpu_all_tmax)); |
526 | |
527 | backside_setup_pid(); |
528 | slots_setup_pid(); |
529 | |
530 | #ifdef HACKED_OVERTEMP |
531 | cpu_all_tmax = 60 << 16; |
532 | #endif |
533 | } |
534 | |
535 | /* Permanent failure, bail out */ |
536 | if (failure_state & FAILURE_PERM) |
537 | return; |
538 | |
539 | /* |
540 | * Clear all failure bits except low overtemp which will be eventually |
541 | * cleared by the control loop itself |
542 | */ |
543 | last_failure = failure_state; |
544 | failure_state &= FAILURE_LOW_OVERTEMP; |
545 | backside_fan_tick(); |
546 | slots_fan_tick(); |
547 | |
548 | /* We do CPUs last because they can be clamped high by |
549 | * DIMM temperature |
550 | */ |
551 | cpu_fans_tick(); |
552 | |
553 | DBG_LOTS(" last_failure: 0x%x, failure_state: %x\n" , |
554 | last_failure, failure_state); |
555 | |
556 | /* Check for failures. Any failure causes cpufreq clamping */ |
557 | if (failure_state && last_failure == 0 && cpufreq_clamp) |
558 | wf_control_set_max(ct: cpufreq_clamp); |
559 | if (failure_state == 0 && last_failure && cpufreq_clamp) |
560 | wf_control_set_min(ct: cpufreq_clamp); |
561 | |
562 | /* That's it for now, we might want to deal with other failures |
563 | * differently in the future though |
564 | */ |
565 | } |
566 | |
567 | static void rm31_new_control(struct wf_control *ct) |
568 | { |
569 | bool all_controls; |
570 | |
571 | if (!strcmp(ct->name, "cpu-fan-a-0" )) |
572 | cpu_fans[0][0] = ct; |
573 | else if (!strcmp(ct->name, "cpu-fan-b-0" )) |
574 | cpu_fans[0][1] = ct; |
575 | else if (!strcmp(ct->name, "cpu-fan-c-0" )) |
576 | cpu_fans[0][2] = ct; |
577 | else if (!strcmp(ct->name, "cpu-fan-a-1" )) |
578 | cpu_fans[1][0] = ct; |
579 | else if (!strcmp(ct->name, "cpu-fan-b-1" )) |
580 | cpu_fans[1][1] = ct; |
581 | else if (!strcmp(ct->name, "cpu-fan-c-1" )) |
582 | cpu_fans[1][2] = ct; |
583 | else if (!strcmp(ct->name, "backside-fan" )) |
584 | backside_fan = ct; |
585 | else if (!strcmp(ct->name, "slots-fan" )) |
586 | slots_fan = ct; |
587 | else if (!strcmp(ct->name, "cpufreq-clamp" )) |
588 | cpufreq_clamp = ct; |
589 | |
590 | all_controls = |
591 | cpu_fans[0][0] && |
592 | cpu_fans[0][1] && |
593 | cpu_fans[0][2] && |
594 | backside_fan && |
595 | slots_fan; |
596 | if (nr_chips > 1) |
597 | all_controls &= |
598 | cpu_fans[1][0] && |
599 | cpu_fans[1][1] && |
600 | cpu_fans[1][2]; |
601 | have_all_controls = all_controls; |
602 | } |
603 | |
604 | |
605 | static void rm31_new_sensor(struct wf_sensor *sr) |
606 | { |
607 | bool all_sensors; |
608 | |
609 | if (!strcmp(sr->name, "cpu-diode-temp-0" )) |
610 | sens_cpu_temp[0] = sr; |
611 | else if (!strcmp(sr->name, "cpu-diode-temp-1" )) |
612 | sens_cpu_temp[1] = sr; |
613 | else if (!strcmp(sr->name, "cpu-voltage-0" )) |
614 | sens_cpu_volts[0] = sr; |
615 | else if (!strcmp(sr->name, "cpu-voltage-1" )) |
616 | sens_cpu_volts[1] = sr; |
617 | else if (!strcmp(sr->name, "cpu-current-0" )) |
618 | sens_cpu_amps[0] = sr; |
619 | else if (!strcmp(sr->name, "cpu-current-1" )) |
620 | sens_cpu_amps[1] = sr; |
621 | else if (!strcmp(sr->name, "backside-temp" )) |
622 | backside_temp = sr; |
623 | else if (!strcmp(sr->name, "slots-temp" )) |
624 | slots_temp = sr; |
625 | else if (!strcmp(sr->name, "dimms-temp" )) |
626 | dimms_temp = sr; |
627 | |
628 | all_sensors = |
629 | sens_cpu_temp[0] && |
630 | sens_cpu_volts[0] && |
631 | sens_cpu_amps[0] && |
632 | backside_temp && |
633 | slots_temp && |
634 | dimms_temp; |
635 | if (nr_chips > 1) |
636 | all_sensors &= |
637 | sens_cpu_temp[1] && |
638 | sens_cpu_volts[1] && |
639 | sens_cpu_amps[1]; |
640 | |
641 | have_all_sensors = all_sensors; |
642 | } |
643 | |
644 | static int rm31_wf_notify(struct notifier_block *self, |
645 | unsigned long event, void *data) |
646 | { |
647 | switch (event) { |
648 | case WF_EVENT_NEW_SENSOR: |
649 | rm31_new_sensor(sr: data); |
650 | break; |
651 | case WF_EVENT_NEW_CONTROL: |
652 | rm31_new_control(ct: data); |
653 | break; |
654 | case WF_EVENT_TICK: |
655 | if (have_all_controls && have_all_sensors) |
656 | rm31_tick(); |
657 | } |
658 | return 0; |
659 | } |
660 | |
661 | static struct notifier_block rm31_events = { |
662 | .notifier_call = rm31_wf_notify, |
663 | }; |
664 | |
665 | static int wf_rm31_probe(struct platform_device *dev) |
666 | { |
667 | wf_register_client(nb: &rm31_events); |
668 | return 0; |
669 | } |
670 | |
671 | static void wf_rm31_remove(struct platform_device *dev) |
672 | { |
673 | wf_unregister_client(nb: &rm31_events); |
674 | } |
675 | |
676 | static struct platform_driver wf_rm31_driver = { |
677 | .probe = wf_rm31_probe, |
678 | .remove_new = wf_rm31_remove, |
679 | .driver = { |
680 | .name = "windfarm" , |
681 | }, |
682 | }; |
683 | |
684 | static int __init wf_rm31_init(void) |
685 | { |
686 | struct device_node *cpu; |
687 | int i; |
688 | |
689 | if (!of_machine_is_compatible(compat: "RackMac3,1" )) |
690 | return -ENODEV; |
691 | |
692 | /* Count the number of CPU cores */ |
693 | nr_chips = 0; |
694 | for_each_node_by_type(cpu, "cpu" ) |
695 | ++nr_chips; |
696 | if (nr_chips > NR_CHIPS) |
697 | nr_chips = NR_CHIPS; |
698 | |
699 | pr_info("windfarm: Initializing for desktop G5 with %d chips\n" , |
700 | nr_chips); |
701 | |
702 | /* Get MPU data for each CPU */ |
703 | for (i = 0; i < nr_chips; i++) { |
704 | cpu_mpu_data[i] = wf_get_mpu(cpu: i); |
705 | if (!cpu_mpu_data[i]) { |
706 | pr_err("wf_rm31: Failed to find MPU data for CPU %d\n" , i); |
707 | return -ENXIO; |
708 | } |
709 | } |
710 | |
711 | #ifdef MODULE |
712 | request_module("windfarm_fcu_controls" ); |
713 | request_module("windfarm_lm75_sensor" ); |
714 | request_module("windfarm_lm87_sensor" ); |
715 | request_module("windfarm_ad7417_sensor" ); |
716 | request_module("windfarm_max6690_sensor" ); |
717 | request_module("windfarm_cpufreq_clamp" ); |
718 | #endif /* MODULE */ |
719 | |
720 | platform_driver_register(&wf_rm31_driver); |
721 | return 0; |
722 | } |
723 | |
724 | static void __exit wf_rm31_exit(void) |
725 | { |
726 | platform_driver_unregister(&wf_rm31_driver); |
727 | } |
728 | |
729 | module_init(wf_rm31_init); |
730 | module_exit(wf_rm31_exit); |
731 | |
732 | MODULE_AUTHOR("Benjamin Herrenschmidt <benh@kernel.crashing.org>" ); |
733 | MODULE_DESCRIPTION("Thermal control for Xserve G5" ); |
734 | MODULE_LICENSE("GPL" ); |
735 | MODULE_ALIAS("platform:windfarm" ); |
736 | |