[linux.git] / drivers / macintosh / windfarm_rm31.c

/*
 * Windfarm PowerMac thermal control.
 * Control loops for RackMack3,1 (Xserve G5)
 *
 * Copyright (C) 2012 Benjamin Herrenschmidt, IBM Corp.
 *
 * Use and redistribute under the terms of the GNU GPL v2.
 */
#include <linux/types.h>
#include <linux/errno.h>
#include <linux/kernel.h>
#include <linux/device.h>
#include <linux/platform_device.h>
#include <linux/reboot.h>
#include <asm/prom.h>
#include <asm/smu.h>

#include "windfarm.h"
#include "windfarm_pid.h"
#include "windfarm_mpu.h"

#define VERSION "1.0"

#undef DEBUG
#undef LOTSA_DEBUG

#ifdef DEBUG
#define DBG(args...)	printk(args)
#else
#define DBG(args...)	do { } while(0)
#endif

#ifdef LOTSA_DEBUG
#define DBG_LOTS(args...)	printk(args)
#else
#define DBG_LOTS(args...)	do { } while(0)
#endif

/* define this to force CPU overtemp to 60 degree, useful for testing
 * the overtemp code
 */
#undef HACKED_OVERTEMP

/* We currently only handle 2 chips */
#define NR_CHIPS	2
#define NR_CPU_FANS	3 * NR_CHIPS

/* Controls and sensors */
static struct wf_sensor *sens_cpu_temp[NR_CHIPS];
static struct wf_sensor *sens_cpu_volts[NR_CHIPS];
static struct wf_sensor *sens_cpu_amps[NR_CHIPS];
static struct wf_sensor *backside_temp;
static struct wf_sensor *slots_temp;
static struct wf_sensor *dimms_temp;

static struct wf_control *cpu_fans[NR_CHIPS][3];
static struct wf_control *backside_fan;
static struct wf_control *slots_fan;
static struct wf_control *cpufreq_clamp;

/* We keep a temperature history for average calculation of 180s */
#define CPU_TEMP_HIST_SIZE	180

/* PID loop state */
static const struct mpu_data *cpu_mpu_data[NR_CHIPS];
static struct wf_cpu_pid_state cpu_pid[NR_CHIPS];
static u32 cpu_thist[CPU_TEMP_HIST_SIZE];
static int cpu_thist_pt;
static s64 cpu_thist_total;
static s32 cpu_all_tmax = 100 << 16;
static struct wf_pid_state backside_pid;
static int backside_tick;
static struct wf_pid_state slots_pid;
static int slots_tick;
static int slots_speed;
static struct wf_pid_state dimms_pid;
static int dimms_output_clamp;

static int nr_chips;
static bool have_all_controls;
static bool have_all_sensors;
static bool started;

static int failure_state;
#define FAILURE_SENSOR		1
#define FAILURE_FAN		2
#define FAILURE_PERM		4
#define FAILURE_LOW_OVERTEMP	8
#define FAILURE_HIGH_OVERTEMP	16

/* Overtemp values */
#define LOW_OVER_AVERAGE	0
#define LOW_OVER_IMMEDIATE	(10 << 16)
#define LOW_OVER_CLEAR		((-10) << 16)
#define HIGH_OVER_IMMEDIATE	(14 << 16)
#define HIGH_OVER_AVERAGE	(10 << 16)
#define HIGH_OVER_IMMEDIATE	(14 << 16)


static void cpu_max_all_fans(void)
{
	int i;

	/* We max all CPU fans in case of a sensor error. We also do the
	 * cpufreq clamping now, even if it's supposedly done later by the
	 * generic code anyway, we do it earlier here to react faster
	 */
	if (cpufreq_clamp)
		wf_control_set_max(cpufreq_clamp);
	for (i = 0; i < nr_chips; i++) {
		if (cpu_fans[i][0])
			wf_control_set_max(cpu_fans[i][0]);
		if (cpu_fans[i][1])
			wf_control_set_max(cpu_fans[i][1]);
		if (cpu_fans[i][2])
			wf_control_set_max(cpu_fans[i][2]);
	}
}

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 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], &amps);
	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 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;
			}
		}
	}
}

/* Implementation... */
static int cpu_setup_pid(int cpu)
{
	struct wf_cpu_pid_param pid;
	const struct mpu_data *mpu = cpu_mpu_data[cpu];
	s32 tmax, ttarget, ptarget;
	int fmin, fmax, hsize;

	/* Get PID params from the appropriate MPU EEPROM */
	tmax = mpu->tmax << 16;
	ttarget = mpu->ttarget << 16;
	ptarget = ((s32)(mpu->pmaxh - mpu->padjmax)) << 16;

	DBG("wf_72: CPU%d ttarget = %d.%03d, tmax = %d.%03d\n",
	    cpu, FIX32TOPRINT(ttarget), FIX32TOPRINT(tmax));

	/* We keep a global tmax for overtemp calculations */
	if (tmax < cpu_all_tmax)
		cpu_all_tmax = tmax;

	/* Set PID min/max by using the rear fan min/max */
	fmin = wf_control_get_min(cpu_fans[cpu][0]);
	fmax = wf_control_get_max(cpu_fans[cpu][0]);
	DBG("wf_72: CPU%d max RPM range = [%d..%d]\n", cpu, fmin, fmax);

	/* History size */
	hsize = min_t(int, mpu->tguardband, WF_PID_MAX_HISTORY);
	DBG("wf_72: CPU%d history size = %d\n", cpu, hsize);

	/* Initialize PID loop */
	pid.interval	= 1;	/* seconds */
	pid.history_len = hsize;
	pid.gd		= mpu->pid_gd;
	pid.gp		= mpu->pid_gp;
	pid.gr		= mpu->pid_gr;
	pid.tmax	= tmax;
	pid.ttarget	= ttarget;
	pid.pmaxadj	= ptarget;
	pid.min		= fmin;
	pid.max		= fmax;

	wf_cpu_pid_init(&cpu_pid[cpu], &pid);
	cpu_pid[cpu].target = 4000;
	
	return 0;
}

/* Backside/U3 fan */
static struct wf_pid_param backside_param = {
	.interval	= 1,
	.history_len	= 2,
	.gd		= 0x00500000,
	.gp		= 0x0004cccc,
	.gr		= 0,
	.itarget	= 70 << 16,
	.additive	= 0,
	.min		= 20,
	.max		= 100,
};

/* DIMMs temperature (clamp the backside fan) */
static struct wf_pid_param dimms_param = {
	.interval	= 1,
	.history_len	= 20,
	.gd		= 0,
	.gp		= 0,
	.gr		= 0x06553600,
	.itarget	= 50 << 16,
	.additive	= 0,
	.min		= 4000,
	.max		= 14000,
};

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 backside_setup_pid(void)
{
	/* first time initialize things */
	s32 fmin = wf_control_get_min(backside_fan);
	s32 fmax = wf_control_get_max(backside_fan);
	struct wf_pid_param param;

	param = backside_param;
	param.min = max(param.min, fmin);
	param.max = min(param.max, fmax);
	wf_pid_init(&backside_pid, &param);

	param = dimms_param;
	wf_pid_init(&dimms_pid, &param);

	backside_tick = 1;

	pr_info("wf_rm31: Backside control loop started.\n");
}

/* Slots fan */
static const struct wf_pid_param slots_param = {
	.interval	= 1,
	.history_len	= 20,
	.gd		= 0,
	.gp		= 0,
	.gr		= 0x00100000,
	.itarget	= 3200000,
	.additive	= 0,
	.min		= 20,
	.max		= 100,
};

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 slots_setup_pid(void)
{
	/* first time initialize things */
	s32 fmin = wf_control_get_min(slots_fan);
	s32 fmax = wf_control_get_max(slots_fan);
	struct wf_pid_param param = slots_param;

	param.min = max(param.min, fmin);
	param.max = min(param.max, fmax);
	wf_pid_init(&slots_pid, &param);
	slots_tick = 1;

	pr_info("wf_rm31: Slots control loop started.\n");
}

static void set_fail_state(void)
{
	cpu_max_all_fans();

	if (backside_fan)
		wf_control_set_max(backside_fan);
	if (slots_fan)
		wf_control_set_max(slots_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 rm31_new_control(struct wf_control *ct)
{
	bool all_controls;

	if (!strcmp(ct->name, "cpu-fan-a-0"))
		cpu_fans[0][0] = ct;
	else if (!strcmp(ct->name, "cpu-fan-b-0"))
		cpu_fans[0][1] = ct;
	else if (!strcmp(ct->name, "cpu-fan-c-0"))
		cpu_fans[0][2] = ct;
	else if (!strcmp(ct->name, "cpu-fan-a-1"))
		cpu_fans[1][0] = ct;
	else if (!strcmp(ct->name, "cpu-fan-b-1"))
		cpu_fans[1][1] = ct;
	else if (!strcmp(ct->name, "cpu-fan-c-1"))
		cpu_fans[1][2] = ct;
	else if (!strcmp(ct->name, "backside-fan"))
		backside_fan = ct;
	else if (!strcmp(ct->name, "slots-fan"))
		slots_fan = ct;
	else if (!strcmp(ct->name, "cpufreq-clamp"))
		cpufreq_clamp = ct;

	all_controls =
		cpu_fans[0][0] &&
		cpu_fans[0][1] &&
		cpu_fans[0][2] &&
		backside_fan &&
		slots_fan;
	if (nr_chips > 1)
		all_controls &=
			cpu_fans[1][0] &&
			cpu_fans[1][1] &&
			cpu_fans[1][2];
	have_all_controls = all_controls;
}


static void rm31_new_sensor(struct wf_sensor *sr)
{
	bool all_sensors;

	if (!strcmp(sr->name, "cpu-diode-temp-0"))
		sens_cpu_temp[0] = sr;
	else if (!strcmp(sr->name, "cpu-diode-temp-1"))
		sens_cpu_temp[1] = sr;
	else if (!strcmp(sr->name, "cpu-voltage-0"))
		sens_cpu_volts[0] = sr;
	else if (!strcmp(sr->name, "cpu-voltage-1"))
		sens_cpu_volts[1] = sr;
	else if (!strcmp(sr->name, "cpu-current-0"))
		sens_cpu_amps[0] = sr;
	else if (!strcmp(sr->name, "cpu-current-1"))
		sens_cpu_amps[1] = sr;
	else if (!strcmp(sr->name, "backside-temp"))
		backside_temp = sr;
	else if (!strcmp(sr->name, "slots-temp"))
		slots_temp = sr;
	else if (!strcmp(sr->name, "dimms-temp"))
		dimms_temp = sr;

	all_sensors =
		sens_cpu_temp[0] &&
		sens_cpu_volts[0] &&
		sens_cpu_amps[0] &&
		backside_temp &&
		slots_temp &&
		dimms_temp;
	if (nr_chips > 1)
		all_sensors &=
			sens_cpu_temp[1] &&
			sens_cpu_volts[1] &&
			sens_cpu_amps[1];

	have_all_sensors = all_sensors;
}

static int rm31_wf_notify(struct notifier_block *self,
			  unsigned long event, void *data)
{
	switch (event) {
	case WF_EVENT_NEW_SENSOR:
		rm31_new_sensor(data);
		break;
	case WF_EVENT_NEW_CONTROL:
		rm31_new_control(data);
		break;
	case WF_EVENT_TICK:
		if (have_all_controls && have_all_sensors)
			rm31_tick();
	}
	return 0;
}

static struct notifier_block rm31_events = {
	.notifier_call = rm31_wf_notify,
};

static int wf_rm31_probe(struct platform_device *dev)
{
	wf_register_client(&rm31_events);
	return 0;
}

static int wf_rm31_remove(struct platform_device *dev)
{
	wf_unregister_client(&rm31_events);

	/* should release all sensors and controls */
	return 0;
}

static struct platform_driver wf_rm31_driver = {
	.probe	= wf_rm31_probe,
	.remove	= wf_rm31_remove,
	.driver	= {
		.name = "windfarm",
		.owner	= THIS_MODULE,
	},
};

static int __init wf_rm31_init(void)
{
	struct device_node *cpu;
	int i;

	if (!of_machine_is_compatible("RackMac3,1"))
		return -ENODEV;

	/* Count the number of CPU cores */
	nr_chips = 0;
	for_each_node_by_type(cpu, "cpu")
		++nr_chips;
	if (nr_chips > NR_CHIPS)
		nr_chips = NR_CHIPS;

	pr_info("windfarm: Initializing for desktop G5 with %d chips\n",
		nr_chips);

	/* Get MPU data for each CPU */
	for (i = 0; i < nr_chips; i++) {
		cpu_mpu_data[i] = wf_get_mpu(i);
		if (!cpu_mpu_data[i]) {
			pr_err("wf_rm31: Failed to find MPU data for CPU %d\n", i);
			return -ENXIO;
		}
	}

#ifdef MODULE
	request_module("windfarm_fcu_controls");
	request_module("windfarm_lm75_sensor");
	request_module("windfarm_lm87_sensor");
	request_module("windfarm_ad7417_sensor");
	request_module("windfarm_max6690_sensor");
	request_module("windfarm_cpufreq_clamp");
#endif /* MODULE */

	platform_driver_register(&wf_rm31_driver);
	return 0;
}

static void __exit wf_rm31_exit(void)
{
	platform_driver_unregister(&wf_rm31_driver);
}

module_init(wf_rm31_init);
module_exit(wf_rm31_exit);

MODULE_AUTHOR("Benjamin Herrenschmidt <[email protected]>");
MODULE_DESCRIPTION("Thermal control for Xserve G5");
MODULE_LICENSE("GPL");
MODULE_ALIAS("platform:windfarm");
Commit	Line	Data
6cd32099 BH	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], &amps);
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, &param);
431
432	param = dimms_param;
433	wf_pid_init(&dimms_pid, &param);
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 = {
fe956a1d AK	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,
6cd32099 BH	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, &param);
	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
1da42fb6	672	static int wf_rm31_remove(struct platform_device *dev)
6cd32099 BH	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;
c7c360ee	699	for_each_node_by_type(cpu, "cpu")
6cd32099 BH	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 <[email protected]>");
	738	MODULE_DESCRIPTION("Thermal control for Xserve G5");
	739	MODULE_LICENSE("GPL");
	740	MODULE_ALIAS("platform:windfarm");