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], &s); 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, ¶m); 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, ¶m); 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