1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Windfarm PowerMac thermal control. 4 * Control loops for machines with SMU and PPC970MP processors. 5 * 6 * Copyright (C) 2005 Paul Mackerras, IBM Corp. <paulus@samba.org> 7 * Copyright (C) 2006 Benjamin Herrenschmidt, IBM Corp. 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 21 #define VERSION "0.2" 22 23 #define 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, 4 cores... */ 44 #define NR_CHIPS 2 45 #define NR_CORES 4 46 #define NR_CPU_FANS 3 * NR_CHIPS 47 48 /* Controls and sensors */ 49 static struct wf_sensor *sens_cpu_temp[NR_CORES]; 50 static struct wf_sensor *sens_cpu_power[NR_CORES]; 51 static struct wf_sensor *hd_temp; 52 static struct wf_sensor *slots_power; 53 static struct wf_sensor *u4_temp; 54 55 static struct wf_control *cpu_fans[NR_CPU_FANS]; 56 static char *cpu_fan_names[NR_CPU_FANS] = { 57 "cpu-rear-fan-0", 58 "cpu-rear-fan-1", 59 "cpu-front-fan-0", 60 "cpu-front-fan-1", 61 "cpu-pump-0", 62 "cpu-pump-1", 63 }; 64 static struct wf_control *cpufreq_clamp; 65 66 /* Second pump isn't required (and isn't actually present) */ 67 #define CPU_FANS_REQD (NR_CPU_FANS - 2) 68 #define FIRST_PUMP 4 69 #define LAST_PUMP 5 70 71 /* We keep a temperature history for average calculation of 180s */ 72 #define CPU_TEMP_HIST_SIZE 180 73 74 /* Scale factor for fan speed, *100 */ 75 static int cpu_fan_scale[NR_CPU_FANS] = { 76 100, 77 100, 78 97, /* inlet fans run at 97% of exhaust fan */ 79 97, 80 100, /* updated later */ 81 100, /* updated later */ 82 }; 83 84 static struct wf_control *backside_fan; 85 static struct wf_control *slots_fan; 86 static struct wf_control *drive_bay_fan; 87 88 /* PID loop state */ 89 static struct wf_cpu_pid_state cpu_pid[NR_CORES]; 90 static u32 cpu_thist[CPU_TEMP_HIST_SIZE]; 91 static int cpu_thist_pt; 92 static s64 cpu_thist_total; 93 static s32 cpu_all_tmax = 100 << 16; 94 static int cpu_last_target; 95 static struct wf_pid_state backside_pid; 96 static int backside_tick; 97 static struct wf_pid_state slots_pid; 98 static bool slots_started; 99 static struct wf_pid_state drive_bay_pid; 100 static int drive_bay_tick; 101 102 static int nr_cores; 103 static int have_all_controls; 104 static int have_all_sensors; 105 static bool started; 106 107 static int failure_state; 108 #define FAILURE_SENSOR 1 109 #define FAILURE_FAN 2 110 #define FAILURE_PERM 4 111 #define FAILURE_LOW_OVERTEMP 8 112 #define FAILURE_HIGH_OVERTEMP 16 113 114 /* Overtemp values */ 115 #define LOW_OVER_AVERAGE 0 116 #define LOW_OVER_IMMEDIATE (10 << 16) 117 #define LOW_OVER_CLEAR ((-10) << 16) 118 #define HIGH_OVER_IMMEDIATE (14 << 16) 119 #define HIGH_OVER_AVERAGE (10 << 16) 120 #define HIGH_OVER_IMMEDIATE (14 << 16) 121 122 123 /* Implementation... */ 124 static int create_cpu_loop(int cpu) 125 { 126 int chip = cpu / 2; 127 int core = cpu & 1; 128 struct smu_sdbp_header *hdr; 129 struct smu_sdbp_cpupiddata *piddata; 130 struct wf_cpu_pid_param pid; 131 struct wf_control *main_fan = cpu_fans[0]; 132 s32 tmax; 133 int fmin; 134 135 /* Get PID params from the appropriate SAT */ 136 hdr = smu_sat_get_sdb_partition(chip, 0xC8 + core, NULL); 137 if (hdr == NULL) { 138 printk(KERN_WARNING"windfarm: can't get CPU PID fan config\n"); 139 return -EINVAL; 140 } 141 piddata = (struct smu_sdbp_cpupiddata *)&hdr[1]; 142 143 /* Get FVT params to get Tmax; if not found, assume default */ 144 hdr = smu_sat_get_sdb_partition(chip, 0xC4 + core, NULL); 145 if (hdr) { 146 struct smu_sdbp_fvt *fvt = (struct smu_sdbp_fvt *)&hdr[1]; 147 tmax = fvt->maxtemp << 16; 148 } else 149 tmax = 95 << 16; /* default to 95 degrees C */ 150 151 /* We keep a global tmax for overtemp calculations */ 152 if (tmax < cpu_all_tmax) 153 cpu_all_tmax = tmax; 154 155 /* 156 * Darwin has a minimum fan speed of 1000 rpm for the 4-way and 157 * 515 for the 2-way. That appears to be overkill, so for now, 158 * impose a minimum of 750 or 515. 159 */ 160 fmin = (nr_cores > 2) ? 750 : 515; 161 162 /* Initialize PID loop */ 163 pid.interval = 1; /* seconds */ 164 pid.history_len = piddata->history_len; 165 pid.gd = piddata->gd; 166 pid.gp = piddata->gp; 167 pid.gr = piddata->gr / piddata->history_len; 168 pid.pmaxadj = (piddata->max_power << 16) - (piddata->power_adj << 8); 169 pid.ttarget = tmax - (piddata->target_temp_delta << 16); 170 pid.tmax = tmax; 171 pid.min = main_fan->ops->get_min(main_fan); 172 pid.max = main_fan->ops->get_max(main_fan); 173 if (pid.min < fmin) 174 pid.min = fmin; 175 176 wf_cpu_pid_init(&cpu_pid[cpu], &pid); 177 return 0; 178 } 179 180 static void cpu_max_all_fans(void) 181 { 182 int i; 183 184 /* We max all CPU fans in case of a sensor error. We also do the 185 * cpufreq clamping now, even if it's supposedly done later by the 186 * generic code anyway, we do it earlier here to react faster 187 */ 188 if (cpufreq_clamp) 189 wf_control_set_max(cpufreq_clamp); 190 for (i = 0; i < NR_CPU_FANS; ++i) 191 if (cpu_fans[i]) 192 wf_control_set_max(cpu_fans[i]); 193 } 194 195 static int cpu_check_overtemp(s32 temp) 196 { 197 int new_state = 0; 198 s32 t_avg, t_old; 199 200 /* First check for immediate overtemps */ 201 if (temp >= (cpu_all_tmax + LOW_OVER_IMMEDIATE)) { 202 new_state |= FAILURE_LOW_OVERTEMP; 203 if ((failure_state & FAILURE_LOW_OVERTEMP) == 0) 204 printk(KERN_ERR "windfarm: Overtemp due to immediate CPU" 205 " temperature !\n"); 206 } 207 if (temp >= (cpu_all_tmax + HIGH_OVER_IMMEDIATE)) { 208 new_state |= FAILURE_HIGH_OVERTEMP; 209 if ((failure_state & FAILURE_HIGH_OVERTEMP) == 0) 210 printk(KERN_ERR "windfarm: Critical overtemp due to" 211 " immediate CPU temperature !\n"); 212 } 213 214 /* We calculate a history of max temperatures and use that for the 215 * overtemp management 216 */ 217 t_old = cpu_thist[cpu_thist_pt]; 218 cpu_thist[cpu_thist_pt] = temp; 219 cpu_thist_pt = (cpu_thist_pt + 1) % CPU_TEMP_HIST_SIZE; 220 cpu_thist_total -= t_old; 221 cpu_thist_total += temp; 222 t_avg = cpu_thist_total / CPU_TEMP_HIST_SIZE; 223 224 DBG_LOTS("t_avg = %d.%03d (out: %d.%03d, in: %d.%03d)\n", 225 FIX32TOPRINT(t_avg), FIX32TOPRINT(t_old), FIX32TOPRINT(temp)); 226 227 /* Now check for average overtemps */ 228 if (t_avg >= (cpu_all_tmax + LOW_OVER_AVERAGE)) { 229 new_state |= FAILURE_LOW_OVERTEMP; 230 if ((failure_state & FAILURE_LOW_OVERTEMP) == 0) 231 printk(KERN_ERR "windfarm: Overtemp due to average CPU" 232 " temperature !\n"); 233 } 234 if (t_avg >= (cpu_all_tmax + HIGH_OVER_AVERAGE)) { 235 new_state |= FAILURE_HIGH_OVERTEMP; 236 if ((failure_state & FAILURE_HIGH_OVERTEMP) == 0) 237 printk(KERN_ERR "windfarm: Critical overtemp due to" 238 " average CPU temperature !\n"); 239 } 240 241 /* Now handle overtemp conditions. We don't currently use the windfarm 242 * overtemp handling core as it's not fully suited to the needs of those 243 * new machine. This will be fixed later. 244 */ 245 if (new_state) { 246 /* High overtemp -> immediate shutdown */ 247 if (new_state & FAILURE_HIGH_OVERTEMP) 248 machine_power_off(); 249 if ((failure_state & new_state) != new_state) 250 cpu_max_all_fans(); 251 failure_state |= new_state; 252 } else if ((failure_state & FAILURE_LOW_OVERTEMP) && 253 (temp < (cpu_all_tmax + LOW_OVER_CLEAR))) { 254 printk(KERN_ERR "windfarm: Overtemp condition cleared !\n"); 255 failure_state &= ~FAILURE_LOW_OVERTEMP; 256 } 257 258 return failure_state & (FAILURE_LOW_OVERTEMP | FAILURE_HIGH_OVERTEMP); 259 } 260 261 static void cpu_fans_tick(void) 262 { 263 int err, cpu; 264 s32 greatest_delta = 0; 265 s32 temp, power, t_max = 0; 266 int i, t, target = 0; 267 struct wf_sensor *sr; 268 struct wf_control *ct; 269 struct wf_cpu_pid_state *sp; 270 271 DBG_LOTS(KERN_DEBUG); 272 for (cpu = 0; cpu < nr_cores; ++cpu) { 273 /* Get CPU core temperature */ 274 sr = sens_cpu_temp[cpu]; 275 err = sr->ops->get_value(sr, &temp); 276 if (err) { 277 DBG("\n"); 278 printk(KERN_WARNING "windfarm: CPU %d temperature " 279 "sensor error %d\n", cpu, err); 280 failure_state |= FAILURE_SENSOR; 281 cpu_max_all_fans(); 282 return; 283 } 284 285 /* Keep track of highest temp */ 286 t_max = max(t_max, temp); 287 288 /* Get CPU power */ 289 sr = sens_cpu_power[cpu]; 290 err = sr->ops->get_value(sr, &power); 291 if (err) { 292 DBG("\n"); 293 printk(KERN_WARNING "windfarm: CPU %d power " 294 "sensor error %d\n", cpu, err); 295 failure_state |= FAILURE_SENSOR; 296 cpu_max_all_fans(); 297 return; 298 } 299 300 /* Run PID */ 301 sp = &cpu_pid[cpu]; 302 t = wf_cpu_pid_run(sp, power, temp); 303 304 if (cpu == 0 || sp->last_delta > greatest_delta) { 305 greatest_delta = sp->last_delta; 306 target = t; 307 } 308 DBG_LOTS("[%d] P=%d.%.3d T=%d.%.3d ", 309 cpu, FIX32TOPRINT(power), FIX32TOPRINT(temp)); 310 } 311 DBG_LOTS("fans = %d, t_max = %d.%03d\n", target, FIX32TOPRINT(t_max)); 312 313 /* Darwin limits decrease to 20 per iteration */ 314 if (target < (cpu_last_target - 20)) 315 target = cpu_last_target - 20; 316 cpu_last_target = target; 317 for (cpu = 0; cpu < nr_cores; ++cpu) 318 cpu_pid[cpu].target = target; 319 320 /* Handle possible overtemps */ 321 if (cpu_check_overtemp(t_max)) 322 return; 323 324 /* Set fans */ 325 for (i = 0; i < NR_CPU_FANS; ++i) { 326 ct = cpu_fans[i]; 327 if (ct == NULL) 328 continue; 329 err = ct->ops->set_value(ct, target * cpu_fan_scale[i] / 100); 330 if (err) { 331 printk(KERN_WARNING "windfarm: fan %s reports " 332 "error %d\n", ct->name, err); 333 failure_state |= FAILURE_FAN; 334 break; 335 } 336 } 337 } 338 339 /* Backside/U4 fan */ 340 static struct wf_pid_param backside_param = { 341 .interval = 5, 342 .history_len = 2, 343 .gd = 48 << 20, 344 .gp = 5 << 20, 345 .gr = 0, 346 .itarget = 64 << 16, 347 .additive = 1, 348 }; 349 350 static void backside_fan_tick(void) 351 { 352 s32 temp; 353 int speed; 354 int err; 355 356 if (!backside_fan || !u4_temp) 357 return; 358 if (!backside_tick) { 359 /* first time; initialize things */ 360 printk(KERN_INFO "windfarm: Backside control loop started.\n"); 361 backside_param.min = backside_fan->ops->get_min(backside_fan); 362 backside_param.max = backside_fan->ops->get_max(backside_fan); 363 wf_pid_init(&backside_pid, &backside_param); 364 backside_tick = 1; 365 } 366 if (--backside_tick > 0) 367 return; 368 backside_tick = backside_pid.param.interval; 369 370 err = u4_temp->ops->get_value(u4_temp, &temp); 371 if (err) { 372 printk(KERN_WARNING "windfarm: U4 temp sensor error %d\n", 373 err); 374 failure_state |= FAILURE_SENSOR; 375 wf_control_set_max(backside_fan); 376 return; 377 } 378 speed = wf_pid_run(&backside_pid, temp); 379 DBG_LOTS("backside PID temp=%d.%.3d speed=%d\n", 380 FIX32TOPRINT(temp), speed); 381 382 err = backside_fan->ops->set_value(backside_fan, speed); 383 if (err) { 384 printk(KERN_WARNING "windfarm: backside fan error %d\n", err); 385 failure_state |= FAILURE_FAN; 386 } 387 } 388 389 /* Drive bay fan */ 390 static struct wf_pid_param drive_bay_prm = { 391 .interval = 5, 392 .history_len = 2, 393 .gd = 30 << 20, 394 .gp = 5 << 20, 395 .gr = 0, 396 .itarget = 40 << 16, 397 .additive = 1, 398 }; 399 400 static void drive_bay_fan_tick(void) 401 { 402 s32 temp; 403 int speed; 404 int err; 405 406 if (!drive_bay_fan || !hd_temp) 407 return; 408 if (!drive_bay_tick) { 409 /* first time; initialize things */ 410 printk(KERN_INFO "windfarm: Drive bay control loop started.\n"); 411 drive_bay_prm.min = drive_bay_fan->ops->get_min(drive_bay_fan); 412 drive_bay_prm.max = drive_bay_fan->ops->get_max(drive_bay_fan); 413 wf_pid_init(&drive_bay_pid, &drive_bay_prm); 414 drive_bay_tick = 1; 415 } 416 if (--drive_bay_tick > 0) 417 return; 418 drive_bay_tick = drive_bay_pid.param.interval; 419 420 err = hd_temp->ops->get_value(hd_temp, &temp); 421 if (err) { 422 printk(KERN_WARNING "windfarm: drive bay temp sensor " 423 "error %d\n", err); 424 failure_state |= FAILURE_SENSOR; 425 wf_control_set_max(drive_bay_fan); 426 return; 427 } 428 speed = wf_pid_run(&drive_bay_pid, temp); 429 DBG_LOTS("drive_bay PID temp=%d.%.3d speed=%d\n", 430 FIX32TOPRINT(temp), speed); 431 432 err = drive_bay_fan->ops->set_value(drive_bay_fan, speed); 433 if (err) { 434 printk(KERN_WARNING "windfarm: drive bay fan error %d\n", err); 435 failure_state |= FAILURE_FAN; 436 } 437 } 438 439 /* PCI slots area fan */ 440 /* This makes the fan speed proportional to the power consumed */ 441 static struct wf_pid_param slots_param = { 442 .interval = 1, 443 .history_len = 2, 444 .gd = 0, 445 .gp = 0, 446 .gr = 0x1277952, 447 .itarget = 0, 448 .min = 1560, 449 .max = 3510, 450 }; 451 452 static void slots_fan_tick(void) 453 { 454 s32 power; 455 int speed; 456 int err; 457 458 if (!slots_fan || !slots_power) 459 return; 460 if (!slots_started) { 461 /* first time; initialize things */ 462 printk(KERN_INFO "windfarm: Slots control loop started.\n"); 463 wf_pid_init(&slots_pid, &slots_param); 464 slots_started = true; 465 } 466 467 err = slots_power->ops->get_value(slots_power, &power); 468 if (err) { 469 printk(KERN_WARNING "windfarm: slots power sensor error %d\n", 470 err); 471 failure_state |= FAILURE_SENSOR; 472 wf_control_set_max(slots_fan); 473 return; 474 } 475 speed = wf_pid_run(&slots_pid, power); 476 DBG_LOTS("slots PID power=%d.%.3d speed=%d\n", 477 FIX32TOPRINT(power), speed); 478 479 err = slots_fan->ops->set_value(slots_fan, speed); 480 if (err) { 481 printk(KERN_WARNING "windfarm: slots fan error %d\n", err); 482 failure_state |= FAILURE_FAN; 483 } 484 } 485 486 static void set_fail_state(void) 487 { 488 int i; 489 490 if (cpufreq_clamp) 491 wf_control_set_max(cpufreq_clamp); 492 for (i = 0; i < NR_CPU_FANS; ++i) 493 if (cpu_fans[i]) 494 wf_control_set_max(cpu_fans[i]); 495 if (backside_fan) 496 wf_control_set_max(backside_fan); 497 if (slots_fan) 498 wf_control_set_max(slots_fan); 499 if (drive_bay_fan) 500 wf_control_set_max(drive_bay_fan); 501 } 502 503 static void pm112_tick(void) 504 { 505 int i, last_failure; 506 507 if (!started) { 508 started = true; 509 printk(KERN_INFO "windfarm: CPUs control loops started.\n"); 510 for (i = 0; i < nr_cores; ++i) { 511 if (create_cpu_loop(i) < 0) { 512 failure_state = FAILURE_PERM; 513 set_fail_state(); 514 break; 515 } 516 } 517 DBG_LOTS("cpu_all_tmax=%d.%03d\n", FIX32TOPRINT(cpu_all_tmax)); 518 519 #ifdef HACKED_OVERTEMP 520 cpu_all_tmax = 60 << 16; 521 #endif 522 } 523 524 /* Permanent failure, bail out */ 525 if (failure_state & FAILURE_PERM) 526 return; 527 /* Clear all failure bits except low overtemp which will be eventually 528 * cleared by the control loop itself 529 */ 530 last_failure = failure_state; 531 failure_state &= FAILURE_LOW_OVERTEMP; 532 cpu_fans_tick(); 533 backside_fan_tick(); 534 slots_fan_tick(); 535 drive_bay_fan_tick(); 536 537 DBG_LOTS("last_failure: 0x%x, failure_state: %x\n", 538 last_failure, failure_state); 539 540 /* Check for failures. Any failure causes cpufreq clamping */ 541 if (failure_state && last_failure == 0 && cpufreq_clamp) 542 wf_control_set_max(cpufreq_clamp); 543 if (failure_state == 0 && last_failure && cpufreq_clamp) 544 wf_control_set_min(cpufreq_clamp); 545 546 /* That's it for now, we might want to deal with other failures 547 * differently in the future though 548 */ 549 } 550 551 static void pm112_new_control(struct wf_control *ct) 552 { 553 int i, max_exhaust; 554 555 if (cpufreq_clamp == NULL && !strcmp(ct->name, "cpufreq-clamp")) { 556 if (wf_get_control(ct) == 0) 557 cpufreq_clamp = ct; 558 } 559 560 for (i = 0; i < NR_CPU_FANS; ++i) { 561 if (!strcmp(ct->name, cpu_fan_names[i])) { 562 if (cpu_fans[i] == NULL && wf_get_control(ct) == 0) 563 cpu_fans[i] = ct; 564 break; 565 } 566 } 567 if (i >= NR_CPU_FANS) { 568 /* not a CPU fan, try the others */ 569 if (!strcmp(ct->name, "backside-fan")) { 570 if (backside_fan == NULL && wf_get_control(ct) == 0) 571 backside_fan = ct; 572 } else if (!strcmp(ct->name, "slots-fan")) { 573 if (slots_fan == NULL && wf_get_control(ct) == 0) 574 slots_fan = ct; 575 } else if (!strcmp(ct->name, "drive-bay-fan")) { 576 if (drive_bay_fan == NULL && wf_get_control(ct) == 0) 577 drive_bay_fan = ct; 578 } 579 return; 580 } 581 582 for (i = 0; i < CPU_FANS_REQD; ++i) 583 if (cpu_fans[i] == NULL) 584 return; 585 586 /* work out pump scaling factors */ 587 max_exhaust = cpu_fans[0]->ops->get_max(cpu_fans[0]); 588 for (i = FIRST_PUMP; i <= LAST_PUMP; ++i) 589 if ((ct = cpu_fans[i]) != NULL) 590 cpu_fan_scale[i] = 591 ct->ops->get_max(ct) * 100 / max_exhaust; 592 593 have_all_controls = 1; 594 } 595 596 static void pm112_new_sensor(struct wf_sensor *sr) 597 { 598 unsigned int i; 599 600 if (!strncmp(sr->name, "cpu-temp-", 9)) { 601 i = sr->name[9] - '0'; 602 if (sr->name[10] == 0 && i < NR_CORES && 603 sens_cpu_temp[i] == NULL && wf_get_sensor(sr) == 0) 604 sens_cpu_temp[i] = sr; 605 606 } else if (!strncmp(sr->name, "cpu-power-", 10)) { 607 i = sr->name[10] - '0'; 608 if (sr->name[11] == 0 && i < NR_CORES && 609 sens_cpu_power[i] == NULL && wf_get_sensor(sr) == 0) 610 sens_cpu_power[i] = sr; 611 } else if (!strcmp(sr->name, "hd-temp")) { 612 if (hd_temp == NULL && wf_get_sensor(sr) == 0) 613 hd_temp = sr; 614 } else if (!strcmp(sr->name, "slots-power")) { 615 if (slots_power == NULL && wf_get_sensor(sr) == 0) 616 slots_power = sr; 617 } else if (!strcmp(sr->name, "backside-temp")) { 618 if (u4_temp == NULL && wf_get_sensor(sr) == 0) 619 u4_temp = sr; 620 } else 621 return; 622 623 /* check if we have all the sensors we need */ 624 for (i = 0; i < nr_cores; ++i) 625 if (sens_cpu_temp[i] == NULL || sens_cpu_power[i] == NULL) 626 return; 627 628 have_all_sensors = 1; 629 } 630 631 static int pm112_wf_notify(struct notifier_block *self, 632 unsigned long event, void *data) 633 { 634 switch (event) { 635 case WF_EVENT_NEW_SENSOR: 636 pm112_new_sensor(data); 637 break; 638 case WF_EVENT_NEW_CONTROL: 639 pm112_new_control(data); 640 break; 641 case WF_EVENT_TICK: 642 if (have_all_controls && have_all_sensors) 643 pm112_tick(); 644 } 645 return 0; 646 } 647 648 static struct notifier_block pm112_events = { 649 .notifier_call = pm112_wf_notify, 650 }; 651 652 static int wf_pm112_probe(struct platform_device *dev) 653 { 654 wf_register_client(&pm112_events); 655 return 0; 656 } 657 658 static int wf_pm112_remove(struct platform_device *dev) 659 { 660 wf_unregister_client(&pm112_events); 661 /* should release all sensors and controls */ 662 return 0; 663 } 664 665 static struct platform_driver wf_pm112_driver = { 666 .probe = wf_pm112_probe, 667 .remove = wf_pm112_remove, 668 .driver = { 669 .name = "windfarm", 670 }, 671 }; 672 673 static int __init wf_pm112_init(void) 674 { 675 struct device_node *cpu; 676 677 if (!of_machine_is_compatible("PowerMac11,2")) 678 return -ENODEV; 679 680 /* Count the number of CPU cores */ 681 nr_cores = 0; 682 for_each_node_by_type(cpu, "cpu") 683 ++nr_cores; 684 685 printk(KERN_INFO "windfarm: initializing for dual-core desktop G5\n"); 686 687 #ifdef MODULE 688 request_module("windfarm_smu_controls"); 689 request_module("windfarm_smu_sensors"); 690 request_module("windfarm_smu_sat"); 691 request_module("windfarm_lm75_sensor"); 692 request_module("windfarm_max6690_sensor"); 693 request_module("windfarm_cpufreq_clamp"); 694 695 #endif /* MODULE */ 696 697 platform_driver_register(&wf_pm112_driver); 698 return 0; 699 } 700 701 static void __exit wf_pm112_exit(void) 702 { 703 platform_driver_unregister(&wf_pm112_driver); 704 } 705 706 module_init(wf_pm112_init); 707 module_exit(wf_pm112_exit); 708 709 MODULE_AUTHOR("Paul Mackerras <paulus@samba.org>"); 710 MODULE_DESCRIPTION("Thermal control for PowerMac11,2"); 711 MODULE_LICENSE("GPL"); 712 MODULE_ALIAS("platform:windfarm"); 713