1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* |
3 | * Windfarm PowerMac thermal control. |
4 | * Control loops for machines with SMU and PPC970MP processors. |
5 | * |
6 | * Copyright (C) 2005 Paul Mackerras, IBM Corp. <paulus@samba.org> |
7 | * Copyright (C) 2006 Benjamin Herrenschmidt, IBM Corp. |
8 | */ |
9 | #include <linux/types.h> |
10 | #include <linux/errno.h> |
11 | #include <linux/kernel.h> |
12 | #include <linux/device.h> |
13 | #include <linux/platform_device.h> |
14 | #include <linux/reboot.h> |
15 | #include <linux/of.h> |
16 | #include <linux/slab.h> |
17 | |
18 | #include <asm/smu.h> |
19 | |
20 | #include "windfarm.h" |
21 | #include "windfarm_pid.h" |
22 | |
23 | #define VERSION "0.2" |
24 | |
25 | #define DEBUG |
26 | #undef LOTSA_DEBUG |
27 | |
28 | #ifdef DEBUG |
29 | #define DBG(args...) printk(args) |
30 | #else |
31 | #define DBG(args...) do { } while(0) |
32 | #endif |
33 | |
34 | #ifdef LOTSA_DEBUG |
35 | #define DBG_LOTS(args...) printk(args) |
36 | #else |
37 | #define DBG_LOTS(args...) do { } while(0) |
38 | #endif |
39 | |
40 | /* define this to force CPU overtemp to 60 degree, useful for testing |
41 | * the overtemp code |
42 | */ |
43 | #undef HACKED_OVERTEMP |
44 | |
45 | /* We currently only handle 2 chips, 4 cores... */ |
46 | #define NR_CHIPS 2 |
47 | #define NR_CORES 4 |
48 | #define NR_CPU_FANS 3 * NR_CHIPS |
49 | |
50 | /* Controls and sensors */ |
51 | static struct wf_sensor *sens_cpu_temp[NR_CORES]; |
52 | static struct wf_sensor *sens_cpu_power[NR_CORES]; |
53 | static struct wf_sensor *hd_temp; |
54 | static struct wf_sensor *slots_power; |
55 | static struct wf_sensor *u4_temp; |
56 | |
57 | static struct wf_control *cpu_fans[NR_CPU_FANS]; |
58 | static char *cpu_fan_names[NR_CPU_FANS] = { |
59 | "cpu-rear-fan-0" , |
60 | "cpu-rear-fan-1" , |
61 | "cpu-front-fan-0" , |
62 | "cpu-front-fan-1" , |
63 | "cpu-pump-0" , |
64 | "cpu-pump-1" , |
65 | }; |
66 | static struct wf_control *cpufreq_clamp; |
67 | |
68 | /* Second pump isn't required (and isn't actually present) */ |
69 | #define CPU_FANS_REQD (NR_CPU_FANS - 2) |
70 | #define FIRST_PUMP 4 |
71 | #define LAST_PUMP 5 |
72 | |
73 | /* We keep a temperature history for average calculation of 180s */ |
74 | #define CPU_TEMP_HIST_SIZE 180 |
75 | |
76 | /* Scale factor for fan speed, *100 */ |
77 | static int cpu_fan_scale[NR_CPU_FANS] = { |
78 | 100, |
79 | 100, |
80 | 97, /* inlet fans run at 97% of exhaust fan */ |
81 | 97, |
82 | 100, /* updated later */ |
83 | 100, /* updated later */ |
84 | }; |
85 | |
86 | static struct wf_control *backside_fan; |
87 | static struct wf_control *slots_fan; |
88 | static struct wf_control *drive_bay_fan; |
89 | |
90 | /* PID loop state */ |
91 | static struct wf_cpu_pid_state cpu_pid[NR_CORES]; |
92 | static u32 cpu_thist[CPU_TEMP_HIST_SIZE]; |
93 | static int cpu_thist_pt; |
94 | static s64 cpu_thist_total; |
95 | static s32 cpu_all_tmax = 100 << 16; |
96 | static int cpu_last_target; |
97 | static struct wf_pid_state backside_pid; |
98 | static int backside_tick; |
99 | static struct wf_pid_state slots_pid; |
100 | static bool slots_started; |
101 | static struct wf_pid_state drive_bay_pid; |
102 | static int drive_bay_tick; |
103 | |
104 | static int nr_cores; |
105 | static int have_all_controls; |
106 | static int have_all_sensors; |
107 | static bool started; |
108 | |
109 | static int failure_state; |
110 | #define FAILURE_SENSOR 1 |
111 | #define FAILURE_FAN 2 |
112 | #define FAILURE_PERM 4 |
113 | #define FAILURE_LOW_OVERTEMP 8 |
114 | #define FAILURE_HIGH_OVERTEMP 16 |
115 | |
116 | /* Overtemp values */ |
117 | #define LOW_OVER_AVERAGE 0 |
118 | #define LOW_OVER_IMMEDIATE (10 << 16) |
119 | #define LOW_OVER_CLEAR ((-10) << 16) |
120 | #define HIGH_OVER_IMMEDIATE (14 << 16) |
121 | #define HIGH_OVER_AVERAGE (10 << 16) |
122 | #define HIGH_OVER_IMMEDIATE (14 << 16) |
123 | |
124 | |
125 | /* Implementation... */ |
126 | static int create_cpu_loop(int cpu) |
127 | { |
128 | int chip = cpu / 2; |
129 | int core = cpu & 1; |
130 | struct *hdr; |
131 | struct smu_sdbp_cpupiddata *piddata; |
132 | struct wf_cpu_pid_param pid; |
133 | struct wf_control *main_fan = cpu_fans[0]; |
134 | s32 tmax; |
135 | int fmin; |
136 | |
137 | /* Get FVT params to get Tmax; if not found, assume default */ |
138 | hdr = smu_sat_get_sdb_partition(chip, 0xC4 + core, NULL); |
139 | if (hdr) { |
140 | struct smu_sdbp_fvt *fvt = (struct smu_sdbp_fvt *)&hdr[1]; |
141 | tmax = fvt->maxtemp << 16; |
142 | } else |
143 | tmax = 95 << 16; /* default to 95 degrees C */ |
144 | |
145 | /* We keep a global tmax for overtemp calculations */ |
146 | if (tmax < cpu_all_tmax) |
147 | cpu_all_tmax = tmax; |
148 | |
149 | kfree(objp: hdr); |
150 | |
151 | /* Get PID params from the appropriate SAT */ |
152 | hdr = smu_sat_get_sdb_partition(chip, 0xC8 + core, NULL); |
153 | if (hdr == NULL) { |
154 | printk(KERN_WARNING"windfarm: can't get CPU PID fan config\n" ); |
155 | return -EINVAL; |
156 | } |
157 | piddata = (struct smu_sdbp_cpupiddata *)&hdr[1]; |
158 | |
159 | /* |
160 | * Darwin has a minimum fan speed of 1000 rpm for the 4-way and |
161 | * 515 for the 2-way. That appears to be overkill, so for now, |
162 | * impose a minimum of 750 or 515. |
163 | */ |
164 | fmin = (nr_cores > 2) ? 750 : 515; |
165 | |
166 | /* Initialize PID loop */ |
167 | pid.interval = 1; /* seconds */ |
168 | pid.history_len = piddata->history_len; |
169 | pid.gd = piddata->gd; |
170 | pid.gp = piddata->gp; |
171 | pid.gr = piddata->gr / piddata->history_len; |
172 | pid.pmaxadj = (piddata->max_power << 16) - (piddata->power_adj << 8); |
173 | pid.ttarget = tmax - (piddata->target_temp_delta << 16); |
174 | pid.tmax = tmax; |
175 | pid.min = main_fan->ops->get_min(main_fan); |
176 | pid.max = main_fan->ops->get_max(main_fan); |
177 | if (pid.min < fmin) |
178 | pid.min = fmin; |
179 | |
180 | wf_cpu_pid_init(st: &cpu_pid[cpu], param: &pid); |
181 | |
182 | kfree(objp: hdr); |
183 | |
184 | return 0; |
185 | } |
186 | |
187 | static void cpu_max_all_fans(void) |
188 | { |
189 | int i; |
190 | |
191 | /* We max all CPU fans in case of a sensor error. We also do the |
192 | * cpufreq clamping now, even if it's supposedly done later by the |
193 | * generic code anyway, we do it earlier here to react faster |
194 | */ |
195 | if (cpufreq_clamp) |
196 | wf_control_set_max(ct: cpufreq_clamp); |
197 | for (i = 0; i < NR_CPU_FANS; ++i) |
198 | if (cpu_fans[i]) |
199 | wf_control_set_max(ct: cpu_fans[i]); |
200 | } |
201 | |
202 | static int cpu_check_overtemp(s32 temp) |
203 | { |
204 | int new_state = 0; |
205 | s32 t_avg, t_old; |
206 | |
207 | /* First check for immediate overtemps */ |
208 | if (temp >= (cpu_all_tmax + LOW_OVER_IMMEDIATE)) { |
209 | new_state |= FAILURE_LOW_OVERTEMP; |
210 | if ((failure_state & FAILURE_LOW_OVERTEMP) == 0) |
211 | printk(KERN_ERR "windfarm: Overtemp due to immediate CPU" |
212 | " temperature !\n" ); |
213 | } |
214 | if (temp >= (cpu_all_tmax + HIGH_OVER_IMMEDIATE)) { |
215 | new_state |= FAILURE_HIGH_OVERTEMP; |
216 | if ((failure_state & FAILURE_HIGH_OVERTEMP) == 0) |
217 | printk(KERN_ERR "windfarm: Critical overtemp due to" |
218 | " immediate CPU temperature !\n" ); |
219 | } |
220 | |
221 | /* We calculate a history of max temperatures and use that for the |
222 | * overtemp management |
223 | */ |
224 | t_old = cpu_thist[cpu_thist_pt]; |
225 | cpu_thist[cpu_thist_pt] = temp; |
226 | cpu_thist_pt = (cpu_thist_pt + 1) % CPU_TEMP_HIST_SIZE; |
227 | cpu_thist_total -= t_old; |
228 | cpu_thist_total += temp; |
229 | t_avg = cpu_thist_total / CPU_TEMP_HIST_SIZE; |
230 | |
231 | DBG_LOTS("t_avg = %d.%03d (out: %d.%03d, in: %d.%03d)\n" , |
232 | FIX32TOPRINT(t_avg), FIX32TOPRINT(t_old), FIX32TOPRINT(temp)); |
233 | |
234 | /* Now check for average overtemps */ |
235 | if (t_avg >= (cpu_all_tmax + LOW_OVER_AVERAGE)) { |
236 | new_state |= FAILURE_LOW_OVERTEMP; |
237 | if ((failure_state & FAILURE_LOW_OVERTEMP) == 0) |
238 | printk(KERN_ERR "windfarm: Overtemp due to average CPU" |
239 | " temperature !\n" ); |
240 | } |
241 | if (t_avg >= (cpu_all_tmax + HIGH_OVER_AVERAGE)) { |
242 | new_state |= FAILURE_HIGH_OVERTEMP; |
243 | if ((failure_state & FAILURE_HIGH_OVERTEMP) == 0) |
244 | printk(KERN_ERR "windfarm: Critical overtemp due to" |
245 | " average CPU temperature !\n" ); |
246 | } |
247 | |
248 | /* Now handle overtemp conditions. We don't currently use the windfarm |
249 | * overtemp handling core as it's not fully suited to the needs of those |
250 | * new machine. This will be fixed later. |
251 | */ |
252 | if (new_state) { |
253 | /* High overtemp -> immediate shutdown */ |
254 | if (new_state & FAILURE_HIGH_OVERTEMP) |
255 | machine_power_off(); |
256 | if ((failure_state & new_state) != new_state) |
257 | cpu_max_all_fans(); |
258 | failure_state |= new_state; |
259 | } else if ((failure_state & FAILURE_LOW_OVERTEMP) && |
260 | (temp < (cpu_all_tmax + LOW_OVER_CLEAR))) { |
261 | printk(KERN_ERR "windfarm: Overtemp condition cleared !\n" ); |
262 | failure_state &= ~FAILURE_LOW_OVERTEMP; |
263 | } |
264 | |
265 | return failure_state & (FAILURE_LOW_OVERTEMP | FAILURE_HIGH_OVERTEMP); |
266 | } |
267 | |
268 | static void cpu_fans_tick(void) |
269 | { |
270 | int err, cpu; |
271 | s32 greatest_delta = 0; |
272 | s32 temp, power, t_max = 0; |
273 | int i, t, target = 0; |
274 | struct wf_sensor *sr; |
275 | struct wf_control *ct; |
276 | struct wf_cpu_pid_state *sp; |
277 | |
278 | DBG_LOTS(KERN_DEBUG); |
279 | for (cpu = 0; cpu < nr_cores; ++cpu) { |
280 | /* Get CPU core temperature */ |
281 | sr = sens_cpu_temp[cpu]; |
282 | err = sr->ops->get_value(sr, &temp); |
283 | if (err) { |
284 | DBG("\n" ); |
285 | printk(KERN_WARNING "windfarm: CPU %d temperature " |
286 | "sensor error %d\n" , cpu, err); |
287 | failure_state |= FAILURE_SENSOR; |
288 | cpu_max_all_fans(); |
289 | return; |
290 | } |
291 | |
292 | /* Keep track of highest temp */ |
293 | t_max = max(t_max, temp); |
294 | |
295 | /* Get CPU power */ |
296 | sr = sens_cpu_power[cpu]; |
297 | err = sr->ops->get_value(sr, &power); |
298 | if (err) { |
299 | DBG("\n" ); |
300 | printk(KERN_WARNING "windfarm: CPU %d power " |
301 | "sensor error %d\n" , cpu, err); |
302 | failure_state |= FAILURE_SENSOR; |
303 | cpu_max_all_fans(); |
304 | return; |
305 | } |
306 | |
307 | /* Run PID */ |
308 | sp = &cpu_pid[cpu]; |
309 | t = wf_cpu_pid_run(st: sp, power, temp); |
310 | |
311 | if (cpu == 0 || sp->last_delta > greatest_delta) { |
312 | greatest_delta = sp->last_delta; |
313 | target = t; |
314 | } |
315 | DBG_LOTS("[%d] P=%d.%.3d T=%d.%.3d " , |
316 | cpu, FIX32TOPRINT(power), FIX32TOPRINT(temp)); |
317 | } |
318 | DBG_LOTS("fans = %d, t_max = %d.%03d\n" , target, FIX32TOPRINT(t_max)); |
319 | |
320 | /* Darwin limits decrease to 20 per iteration */ |
321 | if (target < (cpu_last_target - 20)) |
322 | target = cpu_last_target - 20; |
323 | cpu_last_target = target; |
324 | for (cpu = 0; cpu < nr_cores; ++cpu) |
325 | cpu_pid[cpu].target = target; |
326 | |
327 | /* Handle possible overtemps */ |
328 | if (cpu_check_overtemp(temp: t_max)) |
329 | return; |
330 | |
331 | /* Set fans */ |
332 | for (i = 0; i < NR_CPU_FANS; ++i) { |
333 | ct = cpu_fans[i]; |
334 | if (ct == NULL) |
335 | continue; |
336 | err = ct->ops->set_value(ct, target * cpu_fan_scale[i] / 100); |
337 | if (err) { |
338 | printk(KERN_WARNING "windfarm: fan %s reports " |
339 | "error %d\n" , ct->name, err); |
340 | failure_state |= FAILURE_FAN; |
341 | break; |
342 | } |
343 | } |
344 | } |
345 | |
346 | /* Backside/U4 fan */ |
347 | static struct wf_pid_param backside_param = { |
348 | .interval = 5, |
349 | .history_len = 2, |
350 | .gd = 48 << 20, |
351 | .gp = 5 << 20, |
352 | .gr = 0, |
353 | .itarget = 64 << 16, |
354 | .additive = 1, |
355 | }; |
356 | |
357 | static void backside_fan_tick(void) |
358 | { |
359 | s32 temp; |
360 | int speed; |
361 | int err; |
362 | |
363 | if (!backside_fan || !u4_temp) |
364 | return; |
365 | if (!backside_tick) { |
366 | /* first time; initialize things */ |
367 | printk(KERN_INFO "windfarm: Backside control loop started.\n" ); |
368 | backside_param.min = backside_fan->ops->get_min(backside_fan); |
369 | backside_param.max = backside_fan->ops->get_max(backside_fan); |
370 | wf_pid_init(st: &backside_pid, param: &backside_param); |
371 | backside_tick = 1; |
372 | } |
373 | if (--backside_tick > 0) |
374 | return; |
375 | backside_tick = backside_pid.param.interval; |
376 | |
377 | err = u4_temp->ops->get_value(u4_temp, &temp); |
378 | if (err) { |
379 | printk(KERN_WARNING "windfarm: U4 temp sensor error %d\n" , |
380 | err); |
381 | failure_state |= FAILURE_SENSOR; |
382 | wf_control_set_max(ct: backside_fan); |
383 | return; |
384 | } |
385 | speed = wf_pid_run(st: &backside_pid, sample: temp); |
386 | DBG_LOTS("backside PID temp=%d.%.3d speed=%d\n" , |
387 | FIX32TOPRINT(temp), speed); |
388 | |
389 | err = backside_fan->ops->set_value(backside_fan, speed); |
390 | if (err) { |
391 | printk(KERN_WARNING "windfarm: backside fan error %d\n" , err); |
392 | failure_state |= FAILURE_FAN; |
393 | } |
394 | } |
395 | |
396 | /* Drive bay fan */ |
397 | static struct wf_pid_param drive_bay_prm = { |
398 | .interval = 5, |
399 | .history_len = 2, |
400 | .gd = 30 << 20, |
401 | .gp = 5 << 20, |
402 | .gr = 0, |
403 | .itarget = 40 << 16, |
404 | .additive = 1, |
405 | }; |
406 | |
407 | static void drive_bay_fan_tick(void) |
408 | { |
409 | s32 temp; |
410 | int speed; |
411 | int err; |
412 | |
413 | if (!drive_bay_fan || !hd_temp) |
414 | return; |
415 | if (!drive_bay_tick) { |
416 | /* first time; initialize things */ |
417 | printk(KERN_INFO "windfarm: Drive bay control loop started.\n" ); |
418 | drive_bay_prm.min = drive_bay_fan->ops->get_min(drive_bay_fan); |
419 | drive_bay_prm.max = drive_bay_fan->ops->get_max(drive_bay_fan); |
420 | wf_pid_init(st: &drive_bay_pid, param: &drive_bay_prm); |
421 | drive_bay_tick = 1; |
422 | } |
423 | if (--drive_bay_tick > 0) |
424 | return; |
425 | drive_bay_tick = drive_bay_pid.param.interval; |
426 | |
427 | err = hd_temp->ops->get_value(hd_temp, &temp); |
428 | if (err) { |
429 | printk(KERN_WARNING "windfarm: drive bay temp sensor " |
430 | "error %d\n" , err); |
431 | failure_state |= FAILURE_SENSOR; |
432 | wf_control_set_max(ct: drive_bay_fan); |
433 | return; |
434 | } |
435 | speed = wf_pid_run(st: &drive_bay_pid, sample: temp); |
436 | DBG_LOTS("drive_bay PID temp=%d.%.3d speed=%d\n" , |
437 | FIX32TOPRINT(temp), speed); |
438 | |
439 | err = drive_bay_fan->ops->set_value(drive_bay_fan, speed); |
440 | if (err) { |
441 | printk(KERN_WARNING "windfarm: drive bay fan error %d\n" , err); |
442 | failure_state |= FAILURE_FAN; |
443 | } |
444 | } |
445 | |
446 | /* PCI slots area fan */ |
447 | /* This makes the fan speed proportional to the power consumed */ |
448 | static struct wf_pid_param slots_param = { |
449 | .interval = 1, |
450 | .history_len = 2, |
451 | .gd = 0, |
452 | .gp = 0, |
453 | .gr = 0x1277952, |
454 | .itarget = 0, |
455 | .min = 1560, |
456 | .max = 3510, |
457 | }; |
458 | |
459 | static void slots_fan_tick(void) |
460 | { |
461 | s32 power; |
462 | int speed; |
463 | int err; |
464 | |
465 | if (!slots_fan || !slots_power) |
466 | return; |
467 | if (!slots_started) { |
468 | /* first time; initialize things */ |
469 | printk(KERN_INFO "windfarm: Slots control loop started.\n" ); |
470 | wf_pid_init(st: &slots_pid, param: &slots_param); |
471 | slots_started = true; |
472 | } |
473 | |
474 | err = slots_power->ops->get_value(slots_power, &power); |
475 | if (err) { |
476 | printk(KERN_WARNING "windfarm: slots power sensor error %d\n" , |
477 | err); |
478 | failure_state |= FAILURE_SENSOR; |
479 | wf_control_set_max(ct: slots_fan); |
480 | return; |
481 | } |
482 | speed = wf_pid_run(st: &slots_pid, sample: power); |
483 | DBG_LOTS("slots PID power=%d.%.3d speed=%d\n" , |
484 | FIX32TOPRINT(power), speed); |
485 | |
486 | err = slots_fan->ops->set_value(slots_fan, speed); |
487 | if (err) { |
488 | printk(KERN_WARNING "windfarm: slots fan error %d\n" , err); |
489 | failure_state |= FAILURE_FAN; |
490 | } |
491 | } |
492 | |
493 | static void set_fail_state(void) |
494 | { |
495 | int i; |
496 | |
497 | if (cpufreq_clamp) |
498 | wf_control_set_max(ct: cpufreq_clamp); |
499 | for (i = 0; i < NR_CPU_FANS; ++i) |
500 | if (cpu_fans[i]) |
501 | wf_control_set_max(ct: cpu_fans[i]); |
502 | if (backside_fan) |
503 | wf_control_set_max(ct: backside_fan); |
504 | if (slots_fan) |
505 | wf_control_set_max(ct: slots_fan); |
506 | if (drive_bay_fan) |
507 | wf_control_set_max(ct: drive_bay_fan); |
508 | } |
509 | |
510 | static void pm112_tick(void) |
511 | { |
512 | int i, last_failure; |
513 | |
514 | if (!started) { |
515 | started = true; |
516 | printk(KERN_INFO "windfarm: CPUs control loops started.\n" ); |
517 | for (i = 0; i < nr_cores; ++i) { |
518 | if (create_cpu_loop(cpu: i) < 0) { |
519 | failure_state = FAILURE_PERM; |
520 | set_fail_state(); |
521 | break; |
522 | } |
523 | } |
524 | DBG_LOTS("cpu_all_tmax=%d.%03d\n" , FIX32TOPRINT(cpu_all_tmax)); |
525 | |
526 | #ifdef HACKED_OVERTEMP |
527 | cpu_all_tmax = 60 << 16; |
528 | #endif |
529 | } |
530 | |
531 | /* Permanent failure, bail out */ |
532 | if (failure_state & FAILURE_PERM) |
533 | return; |
534 | /* Clear all failure bits except low overtemp which will be eventually |
535 | * cleared by the control loop itself |
536 | */ |
537 | last_failure = failure_state; |
538 | failure_state &= FAILURE_LOW_OVERTEMP; |
539 | cpu_fans_tick(); |
540 | backside_fan_tick(); |
541 | slots_fan_tick(); |
542 | drive_bay_fan_tick(); |
543 | |
544 | DBG_LOTS("last_failure: 0x%x, failure_state: %x\n" , |
545 | last_failure, failure_state); |
546 | |
547 | /* Check for failures. Any failure causes cpufreq clamping */ |
548 | if (failure_state && last_failure == 0 && cpufreq_clamp) |
549 | wf_control_set_max(ct: cpufreq_clamp); |
550 | if (failure_state == 0 && last_failure && cpufreq_clamp) |
551 | wf_control_set_min(ct: cpufreq_clamp); |
552 | |
553 | /* That's it for now, we might want to deal with other failures |
554 | * differently in the future though |
555 | */ |
556 | } |
557 | |
558 | static void pm112_new_control(struct wf_control *ct) |
559 | { |
560 | int i, max_exhaust; |
561 | |
562 | if (cpufreq_clamp == NULL && !strcmp(ct->name, "cpufreq-clamp" )) { |
563 | if (wf_get_control(ct) == 0) |
564 | cpufreq_clamp = ct; |
565 | } |
566 | |
567 | for (i = 0; i < NR_CPU_FANS; ++i) { |
568 | if (!strcmp(ct->name, cpu_fan_names[i])) { |
569 | if (cpu_fans[i] == NULL && wf_get_control(ct) == 0) |
570 | cpu_fans[i] = ct; |
571 | break; |
572 | } |
573 | } |
574 | if (i >= NR_CPU_FANS) { |
575 | /* not a CPU fan, try the others */ |
576 | if (!strcmp(ct->name, "backside-fan" )) { |
577 | if (backside_fan == NULL && wf_get_control(ct) == 0) |
578 | backside_fan = ct; |
579 | } else if (!strcmp(ct->name, "slots-fan" )) { |
580 | if (slots_fan == NULL && wf_get_control(ct) == 0) |
581 | slots_fan = ct; |
582 | } else if (!strcmp(ct->name, "drive-bay-fan" )) { |
583 | if (drive_bay_fan == NULL && wf_get_control(ct) == 0) |
584 | drive_bay_fan = ct; |
585 | } |
586 | return; |
587 | } |
588 | |
589 | for (i = 0; i < CPU_FANS_REQD; ++i) |
590 | if (cpu_fans[i] == NULL) |
591 | return; |
592 | |
593 | /* work out pump scaling factors */ |
594 | max_exhaust = cpu_fans[0]->ops->get_max(cpu_fans[0]); |
595 | for (i = FIRST_PUMP; i <= LAST_PUMP; ++i) |
596 | if ((ct = cpu_fans[i]) != NULL) |
597 | cpu_fan_scale[i] = |
598 | ct->ops->get_max(ct) * 100 / max_exhaust; |
599 | |
600 | have_all_controls = 1; |
601 | } |
602 | |
603 | static void pm112_new_sensor(struct wf_sensor *sr) |
604 | { |
605 | unsigned int i; |
606 | |
607 | if (!strncmp(sr->name, "cpu-temp-" , 9)) { |
608 | i = sr->name[9] - '0'; |
609 | if (sr->name[10] == 0 && i < NR_CORES && |
610 | sens_cpu_temp[i] == NULL && wf_get_sensor(sr) == 0) |
611 | sens_cpu_temp[i] = sr; |
612 | |
613 | } else if (!strncmp(sr->name, "cpu-power-" , 10)) { |
614 | i = sr->name[10] - '0'; |
615 | if (sr->name[11] == 0 && i < NR_CORES && |
616 | sens_cpu_power[i] == NULL && wf_get_sensor(sr) == 0) |
617 | sens_cpu_power[i] = sr; |
618 | } else if (!strcmp(sr->name, "hd-temp" )) { |
619 | if (hd_temp == NULL && wf_get_sensor(sr) == 0) |
620 | hd_temp = sr; |
621 | } else if (!strcmp(sr->name, "slots-power" )) { |
622 | if (slots_power == NULL && wf_get_sensor(sr) == 0) |
623 | slots_power = sr; |
624 | } else if (!strcmp(sr->name, "backside-temp" )) { |
625 | if (u4_temp == NULL && wf_get_sensor(sr) == 0) |
626 | u4_temp = sr; |
627 | } else |
628 | return; |
629 | |
630 | /* check if we have all the sensors we need */ |
631 | for (i = 0; i < nr_cores; ++i) |
632 | if (sens_cpu_temp[i] == NULL || sens_cpu_power[i] == NULL) |
633 | return; |
634 | |
635 | have_all_sensors = 1; |
636 | } |
637 | |
638 | static int pm112_wf_notify(struct notifier_block *self, |
639 | unsigned long event, void *data) |
640 | { |
641 | switch (event) { |
642 | case WF_EVENT_NEW_SENSOR: |
643 | pm112_new_sensor(sr: data); |
644 | break; |
645 | case WF_EVENT_NEW_CONTROL: |
646 | pm112_new_control(ct: data); |
647 | break; |
648 | case WF_EVENT_TICK: |
649 | if (have_all_controls && have_all_sensors) |
650 | pm112_tick(); |
651 | } |
652 | return 0; |
653 | } |
654 | |
655 | static struct notifier_block pm112_events = { |
656 | .notifier_call = pm112_wf_notify, |
657 | }; |
658 | |
659 | static int wf_pm112_probe(struct platform_device *dev) |
660 | { |
661 | wf_register_client(nb: &pm112_events); |
662 | return 0; |
663 | } |
664 | |
665 | static void wf_pm112_remove(struct platform_device *dev) |
666 | { |
667 | wf_unregister_client(nb: &pm112_events); |
668 | } |
669 | |
670 | static struct platform_driver wf_pm112_driver = { |
671 | .probe = wf_pm112_probe, |
672 | .remove_new = wf_pm112_remove, |
673 | .driver = { |
674 | .name = "windfarm" , |
675 | }, |
676 | }; |
677 | |
678 | static int __init wf_pm112_init(void) |
679 | { |
680 | struct device_node *cpu; |
681 | |
682 | if (!of_machine_is_compatible(compat: "PowerMac11,2" )) |
683 | return -ENODEV; |
684 | |
685 | /* Count the number of CPU cores */ |
686 | nr_cores = 0; |
687 | for_each_node_by_type(cpu, "cpu" ) |
688 | ++nr_cores; |
689 | |
690 | printk(KERN_INFO "windfarm: initializing for dual-core desktop G5\n" ); |
691 | |
692 | #ifdef MODULE |
693 | request_module("windfarm_smu_controls" ); |
694 | request_module("windfarm_smu_sensors" ); |
695 | request_module("windfarm_smu_sat" ); |
696 | request_module("windfarm_lm75_sensor" ); |
697 | request_module("windfarm_max6690_sensor" ); |
698 | request_module("windfarm_cpufreq_clamp" ); |
699 | |
700 | #endif /* MODULE */ |
701 | |
702 | platform_driver_register(&wf_pm112_driver); |
703 | return 0; |
704 | } |
705 | |
706 | static void __exit wf_pm112_exit(void) |
707 | { |
708 | platform_driver_unregister(&wf_pm112_driver); |
709 | } |
710 | |
711 | module_init(wf_pm112_init); |
712 | module_exit(wf_pm112_exit); |
713 | |
714 | MODULE_AUTHOR("Paul Mackerras <paulus@samba.org>" ); |
715 | MODULE_DESCRIPTION("Thermal control for PowerMac11,2" ); |
716 | MODULE_LICENSE("GPL" ); |
717 | MODULE_ALIAS("platform:windfarm" ); |
718 | |