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