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(cpufreq_clamp);
115 	for (i = 0; i < nr_chips; i++) {
116 		if (cpu_front_fans[i])
117 			wf_control_set_max(cpu_front_fans[i]);
118 		if (cpu_rear_fans[i])
119 			wf_control_set_max(cpu_rear_fans[i]);
120 		if (cpu_pumps[i])
121 			wf_control_set_max(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(sens_cpu_temp[cpu], &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(sens_cpu_volts[cpu], &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(sens_cpu_amps[cpu], &amps);
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(cpu_rear_fans[cpu], &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, &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(t_max))
278 			return;
279 
280 		/* Run PID */
281 		wf_cpu_pid_run(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(cpu_rear_fans[cpu], 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(cpu_front_fans[cpu], 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(cpu_rear_fans[0], &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(0, &temp0, &power0);
324 	if (err) {
325 		failure_state |= FAILURE_SENSOR;
326 		cpu_max_all_fans();
327 		return;
328 	}
329 	err = read_one_cpu_vals(1, &temp1, &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(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(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(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(cpu_rear_fans[cpu], 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(cpu_front_fans[cpu], 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(cpu_pumps[cpu], 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(cpu_rear_fans[cpu]);
413 	fmax = wf_control_get_max(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(&cpu_pid[cpu], &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(backside_fan, &speed);
479 	if (!err)
480 		backside_pid.target = speed;
481 
482 	err = wf_sensor_get(backside_temp, &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(backside_fan);
488 		return;
489 	}
490 	speed = wf_pid_run(&backside_pid, temp);
491 
492 	DBG_LOTS("backside PID temp=%d.%.3d speed=%d\n",
493 		 FIX32TOPRINT(temp), speed);
494 
495 	err = wf_control_set(backside_fan, 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(backside_fan);
506 	s32 fmax = wf_control_get_max(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("/u3@0,f8000000");
512 	if (u3 != NULL) {
513 		const u32 *vers = of_get_property(u3, "device-rev", NULL);
514 		if (vers)
515 			if (((*vers) & 0x3f) < 0x34)
516 				u3h = 0;
517 		of_node_put(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(&backside_pid, &param);
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(drives_fan, &speed);
559 	if (!err)
560 		drives_pid.target = speed;
561 
562 	err = wf_sensor_get(drives_temp, &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(drives_fan);
567 		return;
568 	}
569 	speed = wf_pid_run(&drives_pid, temp);
570 
571 	DBG_LOTS("drives PID temp=%d.%.3d speed=%d\n",
572 		 FIX32TOPRINT(temp), speed);
573 
574 	err = wf_control_set(drives_fan, 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(drives_fan);
585 	s32 fmax = wf_control_get_max(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(&drives_pid, &param);
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(backside_fan);
602 	if (slots_fan)
603 		wf_control_set_max(slots_fan);
604 	if (drives_fan)
605 		wf_control_set_max(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(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(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(cpufreq_clamp);
661 	if (failure_state == 0 && last_failure && cpufreq_clamp)
662 		wf_control_set_min(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(data);
757 		break;
758 	case WF_EVENT_NEW_CONTROL:
759 		pm72_new_control(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(&pm72_events);
775 	return 0;
776 }
777 
778 static int wf_pm72_remove(struct platform_device *dev)
779 {
780 	wf_unregister_client(&pm72_events);
781 
782 	/* should release all sensors and controls */
783 	return 0;
784 }
785 
786 static struct platform_driver wf_pm72_driver = {
787 	.probe	= wf_pm72_probe,
788 	.remove	= wf_pm72_remove,
789 	.driver	= {
790 		.name = "windfarm",
791 	},
792 };
793 
794 static int __init wf_pm72_init(void)
795 {
796 	struct device_node *cpu;
797 	int i;
798 
799 	if (!of_machine_is_compatible("PowerMac7,2") &&
800 	    !of_machine_is_compatible("PowerMac7,3"))
801 		return -ENODEV;
802 
803 	/* Count the number of CPU cores */
804 	nr_chips = 0;
805 	for_each_node_by_type(cpu, "cpu")
806 		++nr_chips;
807 	if (nr_chips > NR_CHIPS)
808 		nr_chips = NR_CHIPS;
809 
810 	pr_info("windfarm: Initializing for desktop G5 with %d chips\n",
811 		nr_chips);
812 
813 	/* Get MPU data for each CPU */
814 	for (i = 0; i < nr_chips; i++) {
815 		cpu_mpu_data[i] = wf_get_mpu(i);
816 		if (!cpu_mpu_data[i]) {
817 			pr_err("wf_pm72: Failed to find MPU data for CPU %d\n", i);
818 			return -ENXIO;
819 		}
820 	}
821 
822 #ifdef MODULE
823 	request_module("windfarm_fcu_controls");
824 	request_module("windfarm_lm75_sensor");
825 	request_module("windfarm_ad7417_sensor");
826 	request_module("windfarm_max6690_sensor");
827 	request_module("windfarm_cpufreq_clamp");
828 #endif /* MODULE */
829 
830 	platform_driver_register(&wf_pm72_driver);
831 	return 0;
832 }
833 
834 static void __exit wf_pm72_exit(void)
835 {
836 	platform_driver_unregister(&wf_pm72_driver);
837 }
838 
839 module_init(wf_pm72_init);
840 module_exit(wf_pm72_exit);
841 
842 MODULE_AUTHOR("Benjamin Herrenschmidt <benh@kernel.crashing.org>");
843 MODULE_DESCRIPTION("Thermal control for AGP PowerMac G5s");
844 MODULE_LICENSE("GPL");
845 MODULE_ALIAS("platform:windfarm");
846