static void pm72_tick(void) { int i, last_failure; if (!started) { started = 1; printk(KERN_INFO "windfarm: CPUs control loops started.\n"); for (i = 0; i < nr_chips; ++i) { if (cpu_setup_pid(i) < 0) { failure_state = FAILURE_PERM; set_fail_state(); break; } } DBG_LOTS("cpu_all_tmax=%d.%03d\n", FIX32TOPRINT(cpu_all_tmax)); backside_setup_pid(); drives_setup_pid(); /* * We don't have the right stuff to drive the PCI fan * so we fix it to a default value */ wf_control_set(slots_fan, SLOTS_FAN_DEFAULT_PWM); #ifdef HACKED_OVERTEMP cpu_all_tmax = 60 << 16; #endif } /* Permanent failure, bail out */ if (failure_state & FAILURE_PERM) return; /* * Clear all failure bits except low overtemp which will be eventually * cleared by the control loop itself */ last_failure = failure_state; failure_state &= FAILURE_LOW_OVERTEMP; if (cpu_pid_combined) cpu_fans_tick_combined(); else cpu_fans_tick_split(); backside_fan_tick(); drives_fan_tick(); DBG_LOTS(" last_failure: 0x%x, failure_state: %x\n", last_failure, failure_state); /* Check for failures. Any failure causes cpufreq clamping */ if (failure_state && last_failure == 0 && cpufreq_clamp) wf_control_set_max(cpufreq_clamp); if (failure_state == 0 && last_failure && cpufreq_clamp) wf_control_set_min(cpufreq_clamp); /* That's it for now, we might want to deal with other failures * differently in the future though */ }
static void slots_fan_tick(void) { s32 temp; int speed; int err; if (!slots_fan || !slots_temp || !slots_tick) return; if (--slots_tick > 0) return; slots_tick = slots_pid.param.interval; DBG_LOTS("* slots fans tick\n"); err = wf_sensor_get(slots_temp, &temp); if (err) { pr_warning("wf_rm31: slots temp sensor error %d\n", err); failure_state |= FAILURE_SENSOR; wf_control_set_max(slots_fan); return; } speed = wf_pid_run(&slots_pid, temp); DBG_LOTS("slots PID temp=%d.%.3d speed=%d\n", FIX32TOPRINT(temp), speed); slots_speed = speed; err = wf_control_set(slots_fan, speed); if (err) { printk(KERN_WARNING "windfarm: slots bay fan error %d\n", err); failure_state |= FAILURE_FAN; } }
static void rm31_tick(void) { int i, last_failure; if (!started) { started = 1; printk(KERN_INFO "windfarm: CPUs control loops started.\n"); for (i = 0; i < nr_chips; ++i) { if (cpu_setup_pid(i) < 0) { failure_state = FAILURE_PERM; set_fail_state(); break; } } DBG_LOTS("cpu_all_tmax=%d.%03d\n", FIX32TOPRINT(cpu_all_tmax)); backside_setup_pid(); slots_setup_pid(); #ifdef HACKED_OVERTEMP cpu_all_tmax = 60 << 16; #endif } /* Permanent failure, bail out */ if (failure_state & FAILURE_PERM) return; /* * Clear all failure bits except low overtemp which will be eventually * cleared by the control loop itself */ last_failure = failure_state; failure_state &= FAILURE_LOW_OVERTEMP; backside_fan_tick(); slots_fan_tick(); /* We do CPUs last because they can be clamped high by * DIMM temperature */ cpu_fans_tick(); DBG_LOTS(" last_failure: 0x%x, failure_state: %x\n", last_failure, failure_state); /* Check for failures. Any failure causes cpufreq clamping */ if (failure_state && last_failure == 0 && cpufreq_clamp) wf_control_set_max(cpufreq_clamp); if (failure_state == 0 && last_failure && cpufreq_clamp) wf_control_set_min(cpufreq_clamp); /* That's it for now, we might want to deal with other failures * differently in the future though */ }
static void cpu_fans_tick_split(void) { int err, cpu; s32 intake, temp, power, t_max = 0; DBG_LOTS("* cpu fans_tick_split()\n"); for (cpu = 0; cpu < nr_chips; ++cpu) { struct wf_cpu_pid_state *sp = &cpu_pid[cpu]; /* Read current speed */ wf_control_get(cpu_rear_fans[cpu], &sp->target); DBG_LOTS(" CPU%d: cur_target = %d RPM\n", cpu, sp->target); err = read_one_cpu_vals(cpu, &temp, &power); if (err) { failure_state |= FAILURE_SENSOR; cpu_max_all_fans(); return; } /* Keep track of highest temp */ t_max = max(t_max, temp); /* Handle possible overtemps */ if (cpu_check_overtemp(t_max)) return; /* Run PID */ wf_cpu_pid_run(sp, power, temp); DBG_LOTS(" CPU%d: target = %d RPM\n", cpu, sp->target); /* Apply result directly to exhaust fan */ err = wf_control_set(cpu_rear_fans[cpu], sp->target); if (err) { pr_warning("wf_pm72: Fan %s reports error %d\n", cpu_rear_fans[cpu]->name, err); failure_state |= FAILURE_FAN; break; } /* Scale result for intake fan */ intake = (sp->target * CPU_INTAKE_SCALE) >> 16; DBG_LOTS(" CPU%d: intake = %d RPM\n", cpu, intake); err = wf_control_set(cpu_front_fans[cpu], intake); if (err) { pr_warning("wf_pm72: Fan %s reports error %d\n", cpu_front_fans[cpu]->name, err); failure_state |= FAILURE_FAN; break; } } }
static void backside_fan_tick(void) { s32 temp, dtemp; int speed, dspeed, fan_min; int err; if (!backside_fan || !backside_temp || !dimms_temp || !backside_tick) return; if (--backside_tick > 0) return; backside_tick = backside_pid.param.interval; DBG_LOTS("* backside fans tick\n"); /* Update fan speed from actual fans */ err = wf_control_get(backside_fan, &speed); if (!err) backside_pid.target = speed; err = wf_sensor_get(backside_temp, &temp); if (err) { printk(KERN_WARNING "windfarm: U3 temp sensor error %d\n", err); failure_state |= FAILURE_SENSOR; wf_control_set_max(backside_fan); return; } speed = wf_pid_run(&backside_pid, temp); DBG_LOTS("backside PID temp=%d.%.3d speed=%d\n", FIX32TOPRINT(temp), speed); err = wf_sensor_get(dimms_temp, &dtemp); if (err) { printk(KERN_WARNING "windfarm: DIMMs temp sensor error %d\n", err); failure_state |= FAILURE_SENSOR; wf_control_set_max(backside_fan); return; } dspeed = wf_pid_run(&dimms_pid, dtemp); dimms_output_clamp = dspeed; fan_min = (dspeed * 100) / 14000; fan_min = max(fan_min, backside_param.min); speed = max(speed, fan_min); err = wf_control_set(backside_fan, speed); if (err) { printk(KERN_WARNING "windfarm: backside fan error %d\n", err); failure_state |= FAILURE_FAN; } }
static void slots_fan_tick(void) { s32 power; int speed; int err; if (!slots_fan || !slots_power) return; if (!slots_started) { /* first time; initialize things */ ; wf_pid_init(&slots_pid, &slots_param); slots_started = 1; } err = slots_power->ops->get_value(slots_power, &power); if (err) { // printk(KERN_WARNING "windfarm: slots power sensor error %d\n", ; failure_state |= FAILURE_SENSOR; wf_control_set_max(slots_fan); return; } speed = wf_pid_run(&slots_pid, power); DBG_LOTS("slots PID power=%d.%.3d speed=%d\n", FIX32TOPRINT(power), speed); err = slots_fan->ops->set_value(slots_fan, speed); if (err) { ; failure_state |= FAILURE_FAN; } }
static void pm112_tick(void) { int i, last_failure; if (!started) { started = 1; ; for (i = 0; i < nr_cores; ++i) { if (create_cpu_loop(i) < 0) { failure_state = FAILURE_PERM; set_fail_state(); break; } } DBG_LOTS("cpu_all_tmax=%d.%03d\n", FIX32TOPRINT(cpu_all_tmax)); #ifdef HACKED_OVERTEMP cpu_all_tmax = 60 << 16; #endif } /* Permanent failure, bail out */ if (failure_state & FAILURE_PERM) return; /* Clear all failure bits except low overtemp which will be eventually * cleared by the control loop itself */ last_failure = failure_state; failure_state &= FAILURE_LOW_OVERTEMP; cpu_fans_tick(); backside_fan_tick(); slots_fan_tick(); drive_bay_fan_tick(); DBG_LOTS("last_failure: 0x%x, failure_state: %x\n", last_failure, failure_state); /* Check for failures. Any failure causes cpufreq clamping */ if (failure_state && last_failure == 0 && cpufreq_clamp) wf_control_set_max(cpufreq_clamp); if (failure_state == 0 && last_failure && cpufreq_clamp) wf_control_set_min(cpufreq_clamp); /* That's it for now, we might want to deal with other failures * differently in the future though */ }
static void cpu_fans_tick(void) { int err, cpu, i; s32 speed, temp, power, t_max = 0; DBG_LOTS("* cpu fans_tick_split()\n"); for (cpu = 0; cpu < nr_chips; ++cpu) { struct wf_cpu_pid_state *sp = &cpu_pid[cpu]; /* Read current speed */ wf_control_get(cpu_fans[cpu][0], &sp->target); err = read_one_cpu_vals(cpu, &temp, &power); if (err) { failure_state |= FAILURE_SENSOR; cpu_max_all_fans(); return; } /* Keep track of highest temp */ t_max = max(t_max, temp); /* Handle possible overtemps */ if (cpu_check_overtemp(t_max)) return; /* Run PID */ wf_cpu_pid_run(sp, power, temp); DBG_LOTS(" CPU%d: target = %d RPM\n", cpu, sp->target); /* Apply DIMMs clamp */ speed = max(sp->target, dimms_output_clamp); /* Apply result to all cpu fans */ for (i = 0; i < 3; i++) { err = wf_control_set(cpu_fans[cpu][i], speed); if (err) { pr_warning("wf_rm31: Fan %s reports error %d\n", cpu_fans[cpu][i]->name, err); failure_state |= FAILURE_FAN; } } } }
static int read_one_cpu_vals(int cpu, s32 *temp, s32 *power) { s32 dtemp, volts, amps; int rc; /* Get diode temperature */ rc = wf_sensor_get(sens_cpu_temp[cpu], &dtemp); if (rc) { DBG(" CPU%d: temp reading error !\n", cpu); return -EIO; } DBG_LOTS(" CPU%d: temp = %d.%03d\n", cpu, FIX32TOPRINT((dtemp))); *temp = dtemp; /* Get voltage */ rc = wf_sensor_get(sens_cpu_volts[cpu], &volts); if (rc) { DBG(" CPU%d, volts reading error !\n", cpu); return -EIO; } DBG_LOTS(" CPU%d: volts = %d.%03d\n", cpu, FIX32TOPRINT((volts))); /* Get current */ rc = wf_sensor_get(sens_cpu_amps[cpu], &s); if (rc) { DBG(" CPU%d, current reading error !\n", cpu); return -EIO; } DBG_LOTS(" CPU%d: amps = %d.%03d\n", cpu, FIX32TOPRINT((amps))); /* Calculate power */ /* Scale voltage and current raw sensor values according to fixed scales * obtained in Darwin and calculate power from I and V */ *power = (((u64)volts) * ((u64)amps)) >> 16; DBG_LOTS(" CPU%d: power = %d.%03d\n", cpu, FIX32TOPRINT((*power))); return 0; }
static void backside_fan_tick(void) { s32 temp; int speed; int err; if (!backside_fan || !backside_temp || !backside_tick) return; if (--backside_tick > 0) return; backside_tick = backside_pid.param.interval; DBG_LOTS("* backside fans tick\n"); /* Update fan speed from actual fans */ err = wf_control_get(backside_fan, &speed); if (!err) backside_pid.target = speed; err = wf_sensor_get(backside_temp, &temp); if (err) { printk(KERN_WARNING "windfarm: U4 temp sensor error %d\n", err); failure_state |= FAILURE_SENSOR; wf_control_set_max(backside_fan); return; } speed = wf_pid_run(&backside_pid, temp); DBG_LOTS("backside PID temp=%d.%.3d speed=%d\n", FIX32TOPRINT(temp), speed); err = wf_control_set(backside_fan, speed); if (err) { printk(KERN_WARNING "windfarm: backside fan error %d\n", err); failure_state |= FAILURE_FAN; } }
static void drives_fan_tick(void) { s32 temp; int speed; int err; if (!drives_fan || !drives_temp || !drives_tick) return; if (--drives_tick > 0) return; drives_tick = drives_pid.param.interval; DBG_LOTS("* drives fans tick\n"); /* Update fan speed from actual fans */ err = wf_control_get(drives_fan, &speed); if (!err) drives_pid.target = speed; err = wf_sensor_get(drives_temp, &temp); if (err) { pr_warning("wf_pm72: drive bay temp sensor error %d\n", err); failure_state |= FAILURE_SENSOR; wf_control_set_max(drives_fan); return; } speed = wf_pid_run(&drives_pid, temp); DBG_LOTS("drives PID temp=%d.%.3d speed=%d\n", FIX32TOPRINT(temp), speed); err = wf_control_set(drives_fan, speed); if (err) { printk(KERN_WARNING "windfarm: drive bay fan error %d\n", err); failure_state |= FAILURE_FAN; } }
static void drive_bay_fan_tick(void) { s32 temp; int speed; int err; if (!drive_bay_fan || !hd_temp) return; if (!drive_bay_tick) { /* first time; initialize things */ ; drive_bay_prm.min = drive_bay_fan->ops->get_min(drive_bay_fan); drive_bay_prm.max = drive_bay_fan->ops->get_max(drive_bay_fan); wf_pid_init(&drive_bay_pid, &drive_bay_prm); drive_bay_tick = 1; } if (--drive_bay_tick > 0) return; drive_bay_tick = drive_bay_pid.param.interval; err = hd_temp->ops->get_value(hd_temp, &temp); if (err) { // printk(KERN_WARNING "windfarm: drive bay temp sensor " ; failure_state |= FAILURE_SENSOR; wf_control_set_max(drive_bay_fan); return; } speed = wf_pid_run(&drive_bay_pid, temp); DBG_LOTS("drive_bay PID temp=%d.%.3d speed=%d\n", FIX32TOPRINT(temp), speed); err = drive_bay_fan->ops->set_value(drive_bay_fan, speed); if (err) { ; failure_state |= FAILURE_FAN; } }
static void backside_fan_tick(void) { s32 temp; int speed; int err; if (!backside_fan || !u4_temp) return; if (!backside_tick) { /* first time; initialize things */ ; backside_param.min = backside_fan->ops->get_min(backside_fan); backside_param.max = backside_fan->ops->get_max(backside_fan); wf_pid_init(&backside_pid, &backside_param); backside_tick = 1; } if (--backside_tick > 0) return; backside_tick = backside_pid.param.interval; err = u4_temp->ops->get_value(u4_temp, &temp); if (err) { // printk(KERN_WARNING "windfarm: U4 temp sensor error %d\n", ; failure_state |= FAILURE_SENSOR; wf_control_set_max(backside_fan); return; } speed = wf_pid_run(&backside_pid, temp); DBG_LOTS("backside PID temp=%d.%.3d speed=%d\n", FIX32TOPRINT(temp), speed); err = backside_fan->ops->set_value(backside_fan, speed); if (err) { ; failure_state |= FAILURE_FAN; } }
static int cpu_check_overtemp(s32 temp) { int new_state = 0; s32 t_avg, t_old; static bool first = true; /* First check for immediate overtemps */ if (temp >= (cpu_all_tmax + LOW_OVER_IMMEDIATE)) { new_state |= FAILURE_LOW_OVERTEMP; if ((failure_state & FAILURE_LOW_OVERTEMP) == 0) printk(KERN_ERR "windfarm: Overtemp due to immediate CPU" " temperature !\n"); } if (temp >= (cpu_all_tmax + HIGH_OVER_IMMEDIATE)) { new_state |= FAILURE_HIGH_OVERTEMP; if ((failure_state & FAILURE_HIGH_OVERTEMP) == 0) printk(KERN_ERR "windfarm: Critical overtemp due to" " immediate CPU temperature !\n"); } /* * The first time around, initialize the array with the first * temperature reading */ if (first) { int i; cpu_thist_total = 0; for (i = 0; i < CPU_TEMP_HIST_SIZE; i++) { cpu_thist[i] = temp; cpu_thist_total += temp; } first = false; } /* * We calculate a history of max temperatures and use that for the * overtemp management */ t_old = cpu_thist[cpu_thist_pt]; cpu_thist[cpu_thist_pt] = temp; cpu_thist_pt = (cpu_thist_pt + 1) % CPU_TEMP_HIST_SIZE; cpu_thist_total -= t_old; cpu_thist_total += temp; t_avg = cpu_thist_total / CPU_TEMP_HIST_SIZE; DBG_LOTS(" t_avg = %d.%03d (out: %d.%03d, in: %d.%03d)\n", FIX32TOPRINT(t_avg), FIX32TOPRINT(t_old), FIX32TOPRINT(temp)); /* Now check for average overtemps */ if (t_avg >= (cpu_all_tmax + LOW_OVER_AVERAGE)) { new_state |= FAILURE_LOW_OVERTEMP; if ((failure_state & FAILURE_LOW_OVERTEMP) == 0) printk(KERN_ERR "windfarm: Overtemp due to average CPU" " temperature !\n"); } if (t_avg >= (cpu_all_tmax + HIGH_OVER_AVERAGE)) { new_state |= FAILURE_HIGH_OVERTEMP; if ((failure_state & FAILURE_HIGH_OVERTEMP) == 0) printk(KERN_ERR "windfarm: Critical overtemp due to" " average CPU temperature !\n"); } /* Now handle overtemp conditions. We don't currently use the windfarm * overtemp handling core as it's not fully suited to the needs of those * new machine. This will be fixed later. */ if (new_state) { /* High overtemp -> immediate shutdown */ if (new_state & FAILURE_HIGH_OVERTEMP) machine_power_off(); if ((failure_state & new_state) != new_state) cpu_max_all_fans(); failure_state |= new_state; } else if ((failure_state & FAILURE_LOW_OVERTEMP) && (temp < (cpu_all_tmax + LOW_OVER_CLEAR))) { printk(KERN_ERR "windfarm: Overtemp condition cleared !\n"); failure_state &= ~FAILURE_LOW_OVERTEMP; } return failure_state & (FAILURE_LOW_OVERTEMP | FAILURE_HIGH_OVERTEMP); }
static void cpu_fans_tick(void) { int err, cpu; s32 greatest_delta = 0; s32 temp, power, t_max = 0; int i, t, target = 0; struct wf_sensor *sr; struct wf_control *ct; struct wf_cpu_pid_state *sp; DBG_LOTS(KERN_DEBUG); for (cpu = 0; cpu < nr_cores; ++cpu) { /* Get CPU core temperature */ sr = sens_cpu_temp[cpu]; err = sr->ops->get_value(sr, &temp); if (err) { DBG("\n"); // printk(KERN_WARNING "windfarm: CPU %d temperature " ; failure_state |= FAILURE_SENSOR; cpu_max_all_fans(); return; } /* Keep track of highest temp */ t_max = max(t_max, temp); /* Get CPU power */ sr = sens_cpu_power[cpu]; err = sr->ops->get_value(sr, &power); if (err) { DBG("\n"); // printk(KERN_WARNING "windfarm: CPU %d power " ; failure_state |= FAILURE_SENSOR; cpu_max_all_fans(); return; } /* Run PID */ sp = &cpu_pid[cpu]; t = wf_cpu_pid_run(sp, power, temp); if (cpu == 0 || sp->last_delta > greatest_delta) { greatest_delta = sp->last_delta; target = t; } DBG_LOTS("[%d] P=%d.%.3d T=%d.%.3d ", cpu, FIX32TOPRINT(power), FIX32TOPRINT(temp)); } DBG_LOTS("fans = %d, t_max = %d.%03d\n", target, FIX32TOPRINT(t_max)); /* Darwin limits decrease to 20 per iteration */ if (target < (cpu_last_target - 20)) target = cpu_last_target - 20; cpu_last_target = target; for (cpu = 0; cpu < nr_cores; ++cpu) cpu_pid[cpu].target = target; /* Handle possible overtemps */ if (cpu_check_overtemp(t_max)) return; /* Set fans */ for (i = 0; i < NR_CPU_FANS; ++i) { ct = cpu_fans[i]; if (ct == NULL) continue; err = ct->ops->set_value(ct, target * cpu_fan_scale[i] / 100); if (err) { // printk(KERN_WARNING "windfarm: fan %s reports " ; failure_state |= FAILURE_FAN; break; } } }
static void cpu_fans_tick_combined(void) { s32 temp0, power0, temp1, power1, t_max = 0; s32 temp, power, intake, pump; struct wf_control *pump0, *pump1; struct wf_cpu_pid_state *sp = &cpu_pid[0]; int err, cpu; DBG_LOTS("* cpu fans_tick_combined()\n"); /* Read current speed from cpu 0 */ wf_control_get(cpu_rear_fans[0], &sp->target); DBG_LOTS(" CPUs: cur_target = %d RPM\n", sp->target); /* Read values for both CPUs */ err = read_one_cpu_vals(0, &temp0, &power0); if (err) { failure_state |= FAILURE_SENSOR; cpu_max_all_fans(); return; } err = read_one_cpu_vals(1, &temp1, &power1); if (err) { failure_state |= FAILURE_SENSOR; cpu_max_all_fans(); return; } /* Keep track of highest temp */ t_max = max(t_max, max(temp0, temp1)); /* Handle possible overtemps */ if (cpu_check_overtemp(t_max)) return; /* Use the max temp & power of both */ temp = max(temp0, temp1); power = max(power0, power1); /* Run PID */ wf_cpu_pid_run(sp, power, temp); /* Scale result for intake fan */ intake = (sp->target * CPU_INTAKE_SCALE) >> 16; /* Same deal with pump speed */ pump0 = cpu_pumps[0]; pump1 = cpu_pumps[1]; if (!pump0) { pump0 = pump1; pump1 = NULL; } pump = (sp->target * wf_control_get_max(pump0)) / cpu_mpu_data[0]->rmaxn_exhaust_fan; DBG_LOTS(" CPUs: target = %d RPM\n", sp->target); DBG_LOTS(" CPUs: intake = %d RPM\n", intake); DBG_LOTS(" CPUs: pump = %d RPM\n", pump); for (cpu = 0; cpu < nr_chips; cpu++) { err = wf_control_set(cpu_rear_fans[cpu], sp->target); if (err) { pr_warning("wf_pm72: Fan %s reports error %d\n", cpu_rear_fans[cpu]->name, err); failure_state |= FAILURE_FAN; } err = wf_control_set(cpu_front_fans[cpu], intake); if (err) { pr_warning("wf_pm72: Fan %s reports error %d\n", cpu_front_fans[cpu]->name, err); failure_state |= FAILURE_FAN; } err = 0; if (cpu_pumps[cpu]) err = wf_control_set(cpu_pumps[cpu], pump); if (err) { pr_warning("wf_pm72: Pump %s reports error %d\n", cpu_pumps[cpu]->name, err); failure_state |= FAILURE_FAN; } } }