drivers/macintosh/windfarm_rm31.c

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