Version:  2.6.34 2.6.35 2.6.36 2.6.37 2.6.38 2.6.39 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14

Linux/drivers/macintosh/windfarm_pm72.c

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

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us