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         },
 793 };
 794
 795 static int __init wf_pm72_init(void)
 796 {
 797         struct device_node *cpu;
 798         int i;
 799
 800         if (!of_machine_is_compatible("PowerMac7,2") &&
 801             !of_machine_is_compatible("PowerMac7,3"))
 802                 return -ENODEV;
 803
 804         /* Count the number of CPU cores */
 805         nr_chips = 0;
 806         for_each_node_by_type(cpu, "cpu")
 807                 ++nr_chips;
 808         if (nr_chips > NR_CHIPS)
 809                 nr_chips = NR_CHIPS;
 810
 811         pr_info("windfarm: Initializing for desktop G5 with %d chips\n",
 812                 nr_chips);
 813
 814         /* Get MPU data for each CPU */
 815         for (i = 0; i < nr_chips; i++) {
 816                 cpu_mpu_data[i] = wf_get_mpu(i);
 817                 if (!cpu_mpu_data[i]) {
 818                         pr_err("wf_pm72: Failed to find MPU data for CPU %d\n", i);
 819                         return -ENXIO;
 820                 }
 821         }
 822
 823 #ifdef MODULE
 824         request_module("windfarm_fcu_controls");
 825         request_module("windfarm_lm75_sensor");
 826         request_module("windfarm_ad7417_sensor");
 827         request_module("windfarm_max6690_sensor");
 828         request_module("windfarm_cpufreq_clamp");
 829 #endif /* MODULE */
 830
 831         platform_driver_register(&wf_pm72_driver);
 832         return 0;
 833 }
 834
 835 static void __exit wf_pm72_exit(void)
 836 {
 837         platform_driver_unregister(&wf_pm72_driver);
 838 }
 839
 840 module_init(wf_pm72_init);
 841 module_exit(wf_pm72_exit);
 842
 843 MODULE_AUTHOR("Benjamin Herrenschmidt <benh@kernel.crashing.org>");
 844 MODULE_DESCRIPTION("Thermal control for AGP PowerMac G5s");
 845 MODULE_LICENSE("GPL");
 846 MODULE_ALIAS("platform:windfarm");