1 /* 2 * Windfarm PowerMac thermal control. iMac G5 3 * 4 * (c) Copyright 2005 Benjamin Herrenschmidt, IBM Corp. 5 * <benh@kernel.crashing.org> 6 * 7 * Released under the term of the GNU GPL v2. 8 * 9 * The algorithm used is the PID control algorithm, used the same 10 * way the published Darwin code does, using the same values that 11 * are present in the Darwin 8.2 snapshot property lists (note however 12 * that none of the code has been re-used, it's a complete re-implementation 13 * 14 * The various control loops found in Darwin config file are: 15 * 16 * PowerMac8,1 and PowerMac8,2 17 * =========================== 18 * 19 * System Fans control loop. Different based on models. In addition to the 20 * usual PID algorithm, the control loop gets 2 additional pairs of linear 21 * scaling factors (scale/offsets) expressed as 4.12 fixed point values 22 * signed offset, unsigned scale) 23 * 24 * The targets are modified such as: 25 * - the linked control (second control) gets the target value as-is 26 * (typically the drive fan) 27 * - the main control (first control) gets the target value scaled with 28 * the first pair of factors, and is then modified as below 29 * - the value of the target of the CPU Fan control loop is retrieved, 30 * scaled with the second pair of factors, and the max of that and 31 * the scaled target is applied to the main control. 32 * 33 * # model_id: 2 34 * controls : system-fan, drive-bay-fan 35 * sensors : hd-temp 36 * PID params : G_d = 0x15400000 37 * G_p = 0x00200000 38 * G_r = 0x000002fd 39 * History = 2 entries 40 * Input target = 0x3a0000 41 * Interval = 5s 42 * linear-factors : offset = 0xff38 scale = 0x0ccd 43 * offset = 0x0208 scale = 0x07ae 44 * 45 * # model_id: 3 46 * controls : system-fan, drive-bay-fan 47 * sensors : hd-temp 48 * PID params : G_d = 0x08e00000 49 * G_p = 0x00566666 50 * G_r = 0x0000072b 51 * History = 2 entries 52 * Input target = 0x350000 53 * Interval = 5s 54 * linear-factors : offset = 0xff38 scale = 0x0ccd 55 * offset = 0x0000 scale = 0x0000 56 * 57 * # model_id: 5 58 * controls : system-fan 59 * sensors : hd-temp 60 * PID params : G_d = 0x15400000 61 * G_p = 0x00233333 62 * G_r = 0x000002fd 63 * History = 2 entries 64 * Input target = 0x3a0000 65 * Interval = 5s 66 * linear-factors : offset = 0x0000 scale = 0x1000 67 * offset = 0x0091 scale = 0x0bae 68 * 69 * CPU Fan control loop. The loop is identical for all models. it 70 * has an additional pair of scaling factor. This is used to scale the 71 * systems fan control loop target result (the one before it gets scaled 72 * by the System Fans control loop itself). Then, the max value of the 73 * calculated target value and system fan value is sent to the fans 74 * 75 * controls : cpu-fan 76 * sensors : cpu-temp cpu-power 77 * PID params : From SMU sdb partition 78 * linear-factors : offset = 0xfb50 scale = 0x1000 79 * 80 * CPU Slew control loop. Not implemented. The cpufreq driver in linux is 81 * completely separate for now, though we could find a way to link it, either 82 * as a client reacting to overtemp notifications, or directling monitoring 83 * the CPU temperature 84 * 85 * WARNING ! The CPU control loop requires the CPU tmax for the current 86 * operating point. However, we currently are completely separated from 87 * the cpufreq driver and thus do not know what the current operating 88 * point is. Fortunately, we also do not have any hardware supporting anything 89 * but operating point 0 at the moment, thus we just peek that value directly 90 * from the SDB partition. If we ever end up with actually slewing the system 91 * clock and thus changing operating points, we'll have to find a way to 92 * communicate with the CPU freq driver; 93 * 94 */ 95 96 #include <linux/types.h> 97 #include <linux/errno.h> 98 #include <linux/kernel.h> 99 #include <linux/delay.h> 100 #include <linux/slab.h> 101 #include <linux/init.h> 102 #include <linux/spinlock.h> 103 #include <linux/wait.h> 104 #include <linux/kmod.h> 105 #include <linux/device.h> 106 #include <linux/platform_device.h> 107 #include <asm/prom.h> 108 #include <asm/machdep.h> 109 #include <asm/io.h> 110 #include <asm/system.h> 111 #include <asm/sections.h> 112 #include <asm/smu.h> 113 114 #include "windfarm.h" 115 #include "windfarm_pid.h" 116 117 #define VERSION "0.4" 118 119 #undef DEBUG 120 121 #ifdef DEBUG 122 #define DBG(args...) printk(args) 123 #else 124 #define DBG(args...) do { } while(0) 125 #endif 126 127 /* define this to force CPU overtemp to 74 degree, useful for testing 128 * the overtemp code 129 */ 130 #undef HACKED_OVERTEMP 131 132 static int wf_smu_mach_model; /* machine model id */ 133 134 static struct device *wf_smu_dev; 135 136 /* Controls & sensors */ 137 static struct wf_sensor *sensor_cpu_power; 138 static struct wf_sensor *sensor_cpu_temp; 139 static struct wf_sensor *sensor_hd_temp; 140 static struct wf_control *fan_cpu_main; 141 static struct wf_control *fan_hd; 142 static struct wf_control *fan_system; 143 static struct wf_control *cpufreq_clamp; 144 145 /* Set to kick the control loop into life */ 146 static int wf_smu_all_controls_ok, wf_smu_all_sensors_ok, wf_smu_started; 147 148 /* Failure handling.. could be nicer */ 149 #define FAILURE_FAN 0x01 150 #define FAILURE_SENSOR 0x02 151 #define FAILURE_OVERTEMP 0x04 152 153 static unsigned int wf_smu_failure_state; 154 static int wf_smu_readjust, wf_smu_skipping; 155 156 /* 157 * ****** System Fans Control Loop ****** 158 * 159 */ 160 161 /* Parameters for the System Fans control loop. Parameters 162 * not in this table such as interval, history size, ... 163 * are common to all versions and thus hard coded for now. 164 */ 165 struct wf_smu_sys_fans_param { 166 int model_id; 167 s32 itarget; 168 s32 gd, gp, gr; 169 170 s16 offset0; 171 u16 scale0; 172 s16 offset1; 173 u16 scale1; 174 }; 175 176 #define WF_SMU_SYS_FANS_INTERVAL 5 177 #define WF_SMU_SYS_FANS_HISTORY_SIZE 2 178 179 /* State data used by the system fans control loop 180 */ 181 struct wf_smu_sys_fans_state { 182 int ticks; 183 s32 sys_setpoint; 184 s32 hd_setpoint; 185 s16 offset0; 186 u16 scale0; 187 s16 offset1; 188 u16 scale1; 189 struct wf_pid_state pid; 190 }; 191 192 /* 193 * Configs for SMU Sytem Fan control loop 194 */ 195 static struct wf_smu_sys_fans_param wf_smu_sys_all_params[] = { 196 /* Model ID 2 */ 197 { 198 .model_id = 2, 199 .itarget = 0x3a0000, 200 .gd = 0x15400000, 201 .gp = 0x00200000, 202 .gr = 0x000002fd, 203 .offset0 = 0xff38, 204 .scale0 = 0x0ccd, 205 .offset1 = 0x0208, 206 .scale1 = 0x07ae, 207 }, 208 /* Model ID 3 */ 209 { 210 .model_id = 3, 211 .itarget = 0x350000, 212 .gd = 0x08e00000, 213 .gp = 0x00566666, 214 .gr = 0x0000072b, 215 .offset0 = 0xff38, 216 .scale0 = 0x0ccd, 217 .offset1 = 0x0000, 218 .scale1 = 0x0000, 219 }, 220 /* Model ID 5 */ 221 { 222 .model_id = 5, 223 .itarget = 0x3a0000, 224 .gd = 0x15400000, 225 .gp = 0x00233333, 226 .gr = 0x000002fd, 227 .offset0 = 0x0000, 228 .scale0 = 0x1000, 229 .offset1 = 0x0091, 230 .scale1 = 0x0bae, 231 }, 232 }; 233 #define WF_SMU_SYS_FANS_NUM_CONFIGS ARRAY_SIZE(wf_smu_sys_all_params) 234 235 static struct wf_smu_sys_fans_state *wf_smu_sys_fans; 236 237 /* 238 * ****** CPU Fans Control Loop ****** 239 * 240 */ 241 242 243 #define WF_SMU_CPU_FANS_INTERVAL 1 244 #define WF_SMU_CPU_FANS_MAX_HISTORY 16 245 #define WF_SMU_CPU_FANS_SIBLING_SCALE 0x00001000 246 #define WF_SMU_CPU_FANS_SIBLING_OFFSET 0xfffffb50 247 248 /* State data used by the cpu fans control loop 249 */ 250 struct wf_smu_cpu_fans_state { 251 int ticks; 252 s32 cpu_setpoint; 253 s32 scale; 254 s32 offset; 255 struct wf_cpu_pid_state pid; 256 }; 257 258 static struct wf_smu_cpu_fans_state *wf_smu_cpu_fans; 259 260 261 262 /* 263 * ***** Implementation ***** 264 * 265 */ 266 267 static void wf_smu_create_sys_fans(void) 268 { 269 struct wf_smu_sys_fans_param *param = NULL; 270 struct wf_pid_param pid_param; 271 int i; 272 273 /* First, locate the params for this model */ 274 for (i = 0; i < WF_SMU_SYS_FANS_NUM_CONFIGS; i++) 275 if (wf_smu_sys_all_params[i].model_id == wf_smu_mach_model) { 276 param = &wf_smu_sys_all_params[i]; 277 break; 278 } 279 280 /* No params found, put fans to max */ 281 if (param == NULL) { 282 printk(KERN_WARNING "windfarm: System fan config not found " 283 "for this machine model, max fan speed\n"); 284 goto fail; 285 } 286 287 /* Alloc & initialize state */ 288 wf_smu_sys_fans = kmalloc(sizeof(struct wf_smu_sys_fans_state), 289 GFP_KERNEL); 290 if (wf_smu_sys_fans == NULL) { 291 printk(KERN_WARNING "windfarm: Memory allocation error" 292 " max fan speed\n"); 293 goto fail; 294 } 295 wf_smu_sys_fans->ticks = 1; 296 wf_smu_sys_fans->scale0 = param->scale0; 297 wf_smu_sys_fans->offset0 = param->offset0; 298 wf_smu_sys_fans->scale1 = param->scale1; 299 wf_smu_sys_fans->offset1 = param->offset1; 300 301 /* Fill PID params */ 302 pid_param.gd = param->gd; 303 pid_param.gp = param->gp; 304 pid_param.gr = param->gr; 305 pid_param.interval = WF_SMU_SYS_FANS_INTERVAL; 306 pid_param.history_len = WF_SMU_SYS_FANS_HISTORY_SIZE; 307 pid_param.itarget = param->itarget; 308 pid_param.min = fan_system->ops->get_min(fan_system); 309 pid_param.max = fan_system->ops->get_max(fan_system); 310 if (fan_hd) { 311 pid_param.min = 312 max(pid_param.min,fan_hd->ops->get_min(fan_hd)); 313 pid_param.max = 314 min(pid_param.max,fan_hd->ops->get_max(fan_hd)); 315 } 316 wf_pid_init(&wf_smu_sys_fans->pid, &pid_param); 317 318 DBG("wf: System Fan control initialized.\n"); 319 DBG(" itarged=%d.%03d, min=%d RPM, max=%d RPM\n", 320 FIX32TOPRINT(pid_param.itarget), pid_param.min, pid_param.max); 321 return; 322 323 fail: 324 325 if (fan_system) 326 wf_control_set_max(fan_system); 327 if (fan_hd) 328 wf_control_set_max(fan_hd); 329 } 330 331 static void wf_smu_sys_fans_tick(struct wf_smu_sys_fans_state *st) 332 { 333 s32 new_setpoint, temp, scaled, cputarget; 334 int rc; 335 336 if (--st->ticks != 0) { 337 if (wf_smu_readjust) 338 goto readjust; 339 return; 340 } 341 st->ticks = WF_SMU_SYS_FANS_INTERVAL; 342 343 rc = sensor_hd_temp->ops->get_value(sensor_hd_temp, &temp); 344 if (rc) { 345 printk(KERN_WARNING "windfarm: HD temp sensor error %d\n", 346 rc); 347 wf_smu_failure_state |= FAILURE_SENSOR; 348 return; 349 } 350 351 DBG("wf_smu: System Fans tick ! HD temp: %d.%03d\n", 352 FIX32TOPRINT(temp)); 353 354 if (temp > (st->pid.param.itarget + 0x50000)) 355 wf_smu_failure_state |= FAILURE_OVERTEMP; 356 357 new_setpoint = wf_pid_run(&st->pid, temp); 358 359 DBG("wf_smu: new_setpoint: %d RPM\n", (int)new_setpoint); 360 361 scaled = ((((s64)new_setpoint) * (s64)st->scale0) >> 12) + st->offset0; 362 363 DBG("wf_smu: scaled setpoint: %d RPM\n", (int)scaled); 364 365 cputarget = wf_smu_cpu_fans ? wf_smu_cpu_fans->pid.target : 0; 366 cputarget = ((((s64)cputarget) * (s64)st->scale1) >> 12) + st->offset1; 367 scaled = max(scaled, cputarget); 368 scaled = max(scaled, st->pid.param.min); 369 scaled = min(scaled, st->pid.param.max); 370 371 DBG("wf_smu: adjusted setpoint: %d RPM\n", (int)scaled); 372 373 if (st->sys_setpoint == scaled && new_setpoint == st->hd_setpoint) 374 return; 375 st->sys_setpoint = scaled; 376 st->hd_setpoint = new_setpoint; 377 readjust: 378 if (fan_system && wf_smu_failure_state == 0) { 379 rc = fan_system->ops->set_value(fan_system, st->sys_setpoint); 380 if (rc) { 381 printk(KERN_WARNING "windfarm: Sys fan error %d\n", 382 rc); 383 wf_smu_failure_state |= FAILURE_FAN; 384 } 385 } 386 if (fan_hd && wf_smu_failure_state == 0) { 387 rc = fan_hd->ops->set_value(fan_hd, st->hd_setpoint); 388 if (rc) { 389 printk(KERN_WARNING "windfarm: HD fan error %d\n", 390 rc); 391 wf_smu_failure_state |= FAILURE_FAN; 392 } 393 } 394 } 395 396 static void wf_smu_create_cpu_fans(void) 397 { 398 struct wf_cpu_pid_param pid_param; 399 struct smu_sdbp_header *hdr; 400 struct smu_sdbp_cpupiddata *piddata; 401 struct smu_sdbp_fvt *fvt; 402 s32 tmax, tdelta, maxpow, powadj; 403 404 /* First, locate the PID params in SMU SBD */ 405 hdr = smu_get_sdb_partition(SMU_SDB_CPUPIDDATA_ID, NULL); 406 if (hdr == 0) { 407 printk(KERN_WARNING "windfarm: CPU PID fan config not found " 408 "max fan speed\n"); 409 goto fail; 410 } 411 piddata = (struct smu_sdbp_cpupiddata *)&hdr[1]; 412 413 /* Get the FVT params for operating point 0 (the only supported one 414 * for now) in order to get tmax 415 */ 416 hdr = smu_get_sdb_partition(SMU_SDB_FVT_ID, NULL); 417 if (hdr) { 418 fvt = (struct smu_sdbp_fvt *)&hdr[1]; 419 tmax = ((s32)fvt->maxtemp) << 16; 420 } else 421 tmax = 0x5e0000; /* 94 degree default */ 422 423 /* Alloc & initialize state */ 424 wf_smu_cpu_fans = kmalloc(sizeof(struct wf_smu_cpu_fans_state), 425 GFP_KERNEL); 426 if (wf_smu_cpu_fans == NULL) 427 goto fail; 428 wf_smu_cpu_fans->ticks = 1; 429 430 wf_smu_cpu_fans->scale = WF_SMU_CPU_FANS_SIBLING_SCALE; 431 wf_smu_cpu_fans->offset = WF_SMU_CPU_FANS_SIBLING_OFFSET; 432 433 /* Fill PID params */ 434 pid_param.interval = WF_SMU_CPU_FANS_INTERVAL; 435 pid_param.history_len = piddata->history_len; 436 if (pid_param.history_len > WF_CPU_PID_MAX_HISTORY) { 437 printk(KERN_WARNING "windfarm: History size overflow on " 438 "CPU control loop (%d)\n", piddata->history_len); 439 pid_param.history_len = WF_CPU_PID_MAX_HISTORY; 440 } 441 pid_param.gd = piddata->gd; 442 pid_param.gp = piddata->gp; 443 pid_param.gr = piddata->gr / pid_param.history_len; 444 445 tdelta = ((s32)piddata->target_temp_delta) << 16; 446 maxpow = ((s32)piddata->max_power) << 16; 447 powadj = ((s32)piddata->power_adj) << 16; 448 449 pid_param.tmax = tmax; 450 pid_param.ttarget = tmax - tdelta; 451 pid_param.pmaxadj = maxpow - powadj; 452 453 pid_param.min = fan_cpu_main->ops->get_min(fan_cpu_main); 454 pid_param.max = fan_cpu_main->ops->get_max(fan_cpu_main); 455 456 wf_cpu_pid_init(&wf_smu_cpu_fans->pid, &pid_param); 457 458 DBG("wf: CPU Fan control initialized.\n"); 459 DBG(" ttarged=%d.%03d, tmax=%d.%03d, min=%d RPM, max=%d RPM\n", 460 FIX32TOPRINT(pid_param.ttarget), FIX32TOPRINT(pid_param.tmax), 461 pid_param.min, pid_param.max); 462 463 return; 464 465 fail: 466 printk(KERN_WARNING "windfarm: CPU fan config not found\n" 467 "for this machine model, max fan speed\n"); 468 469 if (cpufreq_clamp) 470 wf_control_set_max(cpufreq_clamp); 471 if (fan_cpu_main) 472 wf_control_set_max(fan_cpu_main); 473 } 474 475 static void wf_smu_cpu_fans_tick(struct wf_smu_cpu_fans_state *st) 476 { 477 s32 new_setpoint, temp, power, systarget; 478 int rc; 479 480 if (--st->ticks != 0) { 481 if (wf_smu_readjust) 482 goto readjust; 483 return; 484 } 485 st->ticks = WF_SMU_CPU_FANS_INTERVAL; 486 487 rc = sensor_cpu_temp->ops->get_value(sensor_cpu_temp, &temp); 488 if (rc) { 489 printk(KERN_WARNING "windfarm: CPU temp sensor error %d\n", 490 rc); 491 wf_smu_failure_state |= FAILURE_SENSOR; 492 return; 493 } 494 495 rc = sensor_cpu_power->ops->get_value(sensor_cpu_power, &power); 496 if (rc) { 497 printk(KERN_WARNING "windfarm: CPU power sensor error %d\n", 498 rc); 499 wf_smu_failure_state |= FAILURE_SENSOR; 500 return; 501 } 502 503 DBG("wf_smu: CPU Fans tick ! CPU temp: %d.%03d, power: %d.%03d\n", 504 FIX32TOPRINT(temp), FIX32TOPRINT(power)); 505 506 #ifdef HACKED_OVERTEMP 507 if (temp > 0x4a0000) 508 wf_smu_failure_state |= FAILURE_OVERTEMP; 509 #else 510 if (temp > st->pid.param.tmax) 511 wf_smu_failure_state |= FAILURE_OVERTEMP; 512 #endif 513 new_setpoint = wf_cpu_pid_run(&st->pid, power, temp); 514 515 DBG("wf_smu: new_setpoint: %d RPM\n", (int)new_setpoint); 516 517 systarget = wf_smu_sys_fans ? wf_smu_sys_fans->pid.target : 0; 518 systarget = ((((s64)systarget) * (s64)st->scale) >> 12) 519 + st->offset; 520 new_setpoint = max(new_setpoint, systarget); 521 new_setpoint = max(new_setpoint, st->pid.param.min); 522 new_setpoint = min(new_setpoint, st->pid.param.max); 523 524 DBG("wf_smu: adjusted setpoint: %d RPM\n", (int)new_setpoint); 525 526 if (st->cpu_setpoint == new_setpoint) 527 return; 528 st->cpu_setpoint = new_setpoint; 529 readjust: 530 if (fan_cpu_main && wf_smu_failure_state == 0) { 531 rc = fan_cpu_main->ops->set_value(fan_cpu_main, 532 st->cpu_setpoint); 533 if (rc) { 534 printk(KERN_WARNING "windfarm: CPU main fan" 535 " error %d\n", rc); 536 wf_smu_failure_state |= FAILURE_FAN; 537 } 538 } 539 } 540 541 /* 542 * ****** Setup / Init / Misc ... ****** 543 * 544 */ 545 546 static void wf_smu_tick(void) 547 { 548 unsigned int last_failure = wf_smu_failure_state; 549 unsigned int new_failure; 550 551 if (!wf_smu_started) { 552 DBG("wf: creating control loops !\n"); 553 wf_smu_create_sys_fans(); 554 wf_smu_create_cpu_fans(); 555 wf_smu_started = 1; 556 } 557 558 /* Skipping ticks */ 559 if (wf_smu_skipping && --wf_smu_skipping) 560 return; 561 562 wf_smu_failure_state = 0; 563 if (wf_smu_sys_fans) 564 wf_smu_sys_fans_tick(wf_smu_sys_fans); 565 if (wf_smu_cpu_fans) 566 wf_smu_cpu_fans_tick(wf_smu_cpu_fans); 567 568 wf_smu_readjust = 0; 569 new_failure = wf_smu_failure_state & ~last_failure; 570 571 /* If entering failure mode, clamp cpufreq and ramp all 572 * fans to full speed. 573 */ 574 if (wf_smu_failure_state && !last_failure) { 575 if (cpufreq_clamp) 576 wf_control_set_max(cpufreq_clamp); 577 if (fan_system) 578 wf_control_set_max(fan_system); 579 if (fan_cpu_main) 580 wf_control_set_max(fan_cpu_main); 581 if (fan_hd) 582 wf_control_set_max(fan_hd); 583 } 584 585 /* If leaving failure mode, unclamp cpufreq and readjust 586 * all fans on next iteration 587 */ 588 if (!wf_smu_failure_state && last_failure) { 589 if (cpufreq_clamp) 590 wf_control_set_min(cpufreq_clamp); 591 wf_smu_readjust = 1; 592 } 593 594 /* Overtemp condition detected, notify and start skipping a couple 595 * ticks to let the temperature go down 596 */ 597 if (new_failure & FAILURE_OVERTEMP) { 598 wf_set_overtemp(); 599 wf_smu_skipping = 2; 600 } 601 602 /* We only clear the overtemp condition if overtemp is cleared 603 * _and_ no other failure is present. Since a sensor error will 604 * clear the overtemp condition (can't measure temperature) at 605 * the control loop levels, but we don't want to keep it clear 606 * here in this case 607 */ 608 if (new_failure == 0 && last_failure & FAILURE_OVERTEMP) 609 wf_clear_overtemp(); 610 } 611 612 static void wf_smu_new_control(struct wf_control *ct) 613 { 614 if (wf_smu_all_controls_ok) 615 return; 616 617 if (fan_cpu_main == NULL && !strcmp(ct->name, "cpu-fan")) { 618 if (wf_get_control(ct) == 0) 619 fan_cpu_main = ct; 620 } 621 622 if (fan_system == NULL && !strcmp(ct->name, "system-fan")) { 623 if (wf_get_control(ct) == 0) 624 fan_system = ct; 625 } 626 627 if (cpufreq_clamp == NULL && !strcmp(ct->name, "cpufreq-clamp")) { 628 if (wf_get_control(ct) == 0) 629 cpufreq_clamp = ct; 630 } 631 632 /* Darwin property list says the HD fan is only for model ID 633 * 0, 1, 2 and 3 634 */ 635 636 if (wf_smu_mach_model > 3) { 637 if (fan_system && fan_cpu_main && cpufreq_clamp) 638 wf_smu_all_controls_ok = 1; 639 return; 640 } 641 642 if (fan_hd == NULL && !strcmp(ct->name, "drive-bay-fan")) { 643 if (wf_get_control(ct) == 0) 644 fan_hd = ct; 645 } 646 647 if (fan_system && fan_hd && fan_cpu_main && cpufreq_clamp) 648 wf_smu_all_controls_ok = 1; 649 } 650 651 static void wf_smu_new_sensor(struct wf_sensor *sr) 652 { 653 if (wf_smu_all_sensors_ok) 654 return; 655 656 if (sensor_cpu_power == NULL && !strcmp(sr->name, "cpu-power")) { 657 if (wf_get_sensor(sr) == 0) 658 sensor_cpu_power = sr; 659 } 660 661 if (sensor_cpu_temp == NULL && !strcmp(sr->name, "cpu-temp")) { 662 if (wf_get_sensor(sr) == 0) 663 sensor_cpu_temp = sr; 664 } 665 666 if (sensor_hd_temp == NULL && !strcmp(sr->name, "hd-temp")) { 667 if (wf_get_sensor(sr) == 0) 668 sensor_hd_temp = sr; 669 } 670 671 if (sensor_cpu_power && sensor_cpu_temp && sensor_hd_temp) 672 wf_smu_all_sensors_ok = 1; 673 } 674 675 676 static int wf_smu_notify(struct notifier_block *self, 677 unsigned long event, void *data) 678 { 679 switch(event) { 680 case WF_EVENT_NEW_CONTROL: 681 DBG("wf: new control %s detected\n", 682 ((struct wf_control *)data)->name); 683 wf_smu_new_control(data); 684 wf_smu_readjust = 1; 685 break; 686 case WF_EVENT_NEW_SENSOR: 687 DBG("wf: new sensor %s detected\n", 688 ((struct wf_sensor *)data)->name); 689 wf_smu_new_sensor(data); 690 break; 691 case WF_EVENT_TICK: 692 if (wf_smu_all_controls_ok && wf_smu_all_sensors_ok) 693 wf_smu_tick(); 694 } 695 696 return 0; 697 } 698 699 static struct notifier_block wf_smu_events = { 700 .notifier_call = wf_smu_notify, 701 }; 702 703 static int wf_init_pm(void) 704 { 705 struct smu_sdbp_header *hdr; 706 707 hdr = smu_get_sdb_partition(SMU_SDB_SENSORTREE_ID, NULL); 708 if (hdr != 0) { 709 struct smu_sdbp_sensortree *st = 710 (struct smu_sdbp_sensortree *)&hdr[1]; 711 wf_smu_mach_model = st->model_id; 712 } 713 714 printk(KERN_INFO "windfarm: Initializing for iMacG5 model ID %d\n", 715 wf_smu_mach_model); 716 717 return 0; 718 } 719 720 static int wf_smu_probe(struct device *ddev) 721 { 722 wf_smu_dev = ddev; 723 724 wf_register_client(&wf_smu_events); 725 726 return 0; 727 } 728 729 static int wf_smu_remove(struct device *ddev) 730 { 731 wf_unregister_client(&wf_smu_events); 732 733 /* XXX We don't have yet a guarantee that our callback isn't 734 * in progress when returning from wf_unregister_client, so 735 * we add an arbitrary delay. I'll have to fix that in the core 736 */ 737 msleep(1000); 738 739 /* Release all sensors */ 740 /* One more crappy race: I don't think we have any guarantee here 741 * that the attribute callback won't race with the sensor beeing 742 * disposed of, and I'm not 100% certain what best way to deal 743 * with that except by adding locks all over... I'll do that 744 * eventually but heh, who ever rmmod this module anyway ? 745 */ 746 if (sensor_cpu_power) 747 wf_put_sensor(sensor_cpu_power); 748 if (sensor_cpu_temp) 749 wf_put_sensor(sensor_cpu_temp); 750 if (sensor_hd_temp) 751 wf_put_sensor(sensor_hd_temp); 752 753 /* Release all controls */ 754 if (fan_cpu_main) 755 wf_put_control(fan_cpu_main); 756 if (fan_hd) 757 wf_put_control(fan_hd); 758 if (fan_system) 759 wf_put_control(fan_system); 760 if (cpufreq_clamp) 761 wf_put_control(cpufreq_clamp); 762 763 /* Destroy control loops state structures */ 764 if (wf_smu_sys_fans) 765 kfree(wf_smu_sys_fans); 766 if (wf_smu_cpu_fans) 767 kfree(wf_smu_cpu_fans); 768 769 wf_smu_dev = NULL; 770 771 return 0; 772 } 773 774 static struct device_driver wf_smu_driver = { 775 .name = "windfarm", 776 .bus = &platform_bus_type, 777 .probe = wf_smu_probe, 778 .remove = wf_smu_remove, 779 }; 780 781 782 static int __init wf_smu_init(void) 783 { 784 int rc = -ENODEV; 785 786 if (machine_is_compatible("PowerMac8,1") || 787 machine_is_compatible("PowerMac8,2")) 788 rc = wf_init_pm(); 789 790 if (rc == 0) { 791 #ifdef MODULE 792 request_module("windfarm_smu_controls"); 793 request_module("windfarm_smu_sensors"); 794 request_module("windfarm_lm75_sensor"); 795 796 #endif /* MODULE */ 797 driver_register(&wf_smu_driver); 798 } 799 800 return rc; 801 } 802 803 static void __exit wf_smu_exit(void) 804 { 805 806 driver_unregister(&wf_smu_driver); 807 } 808 809 810 module_init(wf_smu_init); 811 module_exit(wf_smu_exit); 812 813 MODULE_AUTHOR("Benjamin Herrenschmidt <benh@kernel.crashing.org>"); 814 MODULE_DESCRIPTION("Thermal control logic for iMac G5"); 815 MODULE_LICENSE("GPL"); 816 817