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], &s); 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, ¶m); 431 432 param = dimms_param; 433 wf_pid_init(&dimms_pid, ¶m); 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, ¶m); 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"); 741