[net-next-2.6.git] / drivers / macintosh / windfarm_smu_sensors.c

/*
 * Windfarm PowerMac thermal control. SMU based sensors
 *
 * (c) Copyright 2005 Benjamin Herrenschmidt, IBM Corp.
 *                    <benh@kernel.crashing.org>
 *
 * Released under the term of the GNU GPL v2.
 */

#include <linux/types.h>
#include <linux/errno.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/slab.h>
#include <linux/init.h>
#include <linux/wait.h>
#include <linux/completion.h>
#include <asm/prom.h>
#include <asm/machdep.h>
#include <asm/io.h>
#include <asm/system.h>
#include <asm/sections.h>
#include <asm/smu.h>

#include "windfarm.h"

#define VERSION "0.2"

#undef DEBUG

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

/*
 * Various SMU "partitions" calibration objects for which we
 * keep pointers here for use by bits & pieces of the driver
 */
static struct smu_sdbp_cpuvcp *cpuvcp;
static int  cpuvcp_version;
static struct smu_sdbp_cpudiode *cpudiode;
static struct smu_sdbp_slotspow *slotspow;
static u8 *debugswitches;

/*
 * SMU basic sensors objects
 */

static LIST_HEAD(smu_ads);

struct smu_ad_sensor {
	struct list_head	link;
	u32			reg;		/* index in SMU */
	struct wf_sensor	sens;
};
#define to_smu_ads(c) container_of(c, struct smu_ad_sensor, sens)

static void smu_ads_release(struct wf_sensor *sr)
{
	struct smu_ad_sensor *ads = to_smu_ads(sr);

	kfree(ads);
}

static int smu_read_adc(u8 id, s32 *value)
{
	struct smu_simple_cmd	cmd;
	DECLARE_COMPLETION_ONSTACK(comp);
	int rc;

	rc = smu_queue_simple(&cmd, SMU_CMD_READ_ADC, 1,
			      smu_done_complete, &comp, id);
	if (rc)
		return rc;
	wait_for_completion(&comp);
	if (cmd.cmd.status != 0)
		return cmd.cmd.status;
	if (cmd.cmd.reply_len != 2) {
		printk(KERN_ERR "winfarm: read ADC 0x%x returned %d bytes !\n",
		       id, cmd.cmd.reply_len);
		return -EIO;
	}
	*value = *((u16 *)cmd.buffer);
	return 0;
}

static int smu_cputemp_get(struct wf_sensor *sr, s32 *value)
{
	struct smu_ad_sensor *ads = to_smu_ads(sr);
	int rc;
	s32 val;
	s64 scaled;

	rc = smu_read_adc(ads->reg, &val);
	if (rc) {
		printk(KERN_ERR "windfarm: read CPU temp failed, err %d\n",
		       rc);
		return rc;
	}

	/* Ok, we have to scale & adjust, taking units into account */
	scaled = (s64)(((u64)val) * (u64)cpudiode->m_value);
	scaled >>= 3;
	scaled += ((s64)cpudiode->b_value) << 9;
	*value = (s32)(scaled << 1);

	return 0;
}

static int smu_cpuamp_get(struct wf_sensor *sr, s32 *value)
{
	struct smu_ad_sensor *ads = to_smu_ads(sr);
	s32 val, scaled;
	int rc;

	rc = smu_read_adc(ads->reg, &val);
	if (rc) {
		printk(KERN_ERR "windfarm: read CPU current failed, err %d\n",
		       rc);
		return rc;
	}

	/* Ok, we have to scale & adjust, taking units into account */
	scaled = (s32)(val * (u32)cpuvcp->curr_scale);
	scaled += (s32)cpuvcp->curr_offset;
	*value = scaled << 4;

	return 0;
}

static int smu_cpuvolt_get(struct wf_sensor *sr, s32 *value)
{
	struct smu_ad_sensor *ads = to_smu_ads(sr);
	s32 val, scaled;
	int rc;

	rc = smu_read_adc(ads->reg, &val);
	if (rc) {
		printk(KERN_ERR "windfarm: read CPU voltage failed, err %d\n",
		       rc);
		return rc;
	}

	/* Ok, we have to scale & adjust, taking units into account */
	scaled = (s32)(val * (u32)cpuvcp->volt_scale);
	scaled += (s32)cpuvcp->volt_offset;
	*value = scaled << 4;

	return 0;
}

static int smu_slotspow_get(struct wf_sensor *sr, s32 *value)
{
	struct smu_ad_sensor *ads = to_smu_ads(sr);
	s32 val, scaled;
	int rc;

	rc = smu_read_adc(ads->reg, &val);
	if (rc) {
		printk(KERN_ERR "windfarm: read slots power failed, err %d\n",
		       rc);
		return rc;
	}

	/* Ok, we have to scale & adjust, taking units into account */
	scaled = (s32)(val * (u32)slotspow->pow_scale);
	scaled += (s32)slotspow->pow_offset;
	*value = scaled << 4;

	return 0;
}


static struct wf_sensor_ops smu_cputemp_ops = {
	.get_value	= smu_cputemp_get,
	.release	= smu_ads_release,
	.owner		= THIS_MODULE,
};
static struct wf_sensor_ops smu_cpuamp_ops = {
	.get_value	= smu_cpuamp_get,
	.release	= smu_ads_release,
	.owner		= THIS_MODULE,
};
static struct wf_sensor_ops smu_cpuvolt_ops = {
	.get_value	= smu_cpuvolt_get,
	.release	= smu_ads_release,
	.owner		= THIS_MODULE,
};
static struct wf_sensor_ops smu_slotspow_ops = {
	.get_value	= smu_slotspow_get,
	.release	= smu_ads_release,
	.owner		= THIS_MODULE,
};


static struct smu_ad_sensor *smu_ads_create(struct device_node *node)
{
	struct smu_ad_sensor *ads;
	const char *c, *l;
	const u32 *v;

	ads = kmalloc(sizeof(struct smu_ad_sensor), GFP_KERNEL);
	if (ads == NULL)
		return NULL;
	c = of_get_property(node, "device_type", NULL);
	l = of_get_property(node, "location", NULL);
	if (c == NULL || l == NULL)
		goto fail;

	/* We currently pick the sensors based on the OF name and location
	 * properties, while Darwin uses the sensor-id's.
	 * The problem with the IDs is that they are model specific while it
	 * looks like apple has been doing a reasonably good job at keeping
	 * the names and locations consistents so I'll stick with the names
	 * and locations for now.
	 */
	if (!strcmp(c, "temp-sensor") &&
	    !strcmp(l, "CPU T-Diode")) {
		ads->sens.ops = &smu_cputemp_ops;
		ads->sens.name = "cpu-temp";
		if (cpudiode == NULL) {
			DBG("wf: cpudiode partition (%02x) not found\n",
			    SMU_SDB_CPUDIODE_ID);
			goto fail;
		}
	} else if (!strcmp(c, "current-sensor") &&
		   !strcmp(l, "CPU Current")) {
		ads->sens.ops = &smu_cpuamp_ops;
		ads->sens.name = "cpu-current";
		if (cpuvcp == NULL) {
			DBG("wf: cpuvcp partition (%02x) not found\n",
			    SMU_SDB_CPUVCP_ID);
			goto fail;
		}
	} else if (!strcmp(c, "voltage-sensor") &&
		   !strcmp(l, "CPU Voltage")) {
		ads->sens.ops = &smu_cpuvolt_ops;
		ads->sens.name = "cpu-voltage";
		if (cpuvcp == NULL) {
			DBG("wf: cpuvcp partition (%02x) not found\n",
			    SMU_SDB_CPUVCP_ID);
			goto fail;
		}
	} else if (!strcmp(c, "power-sensor") &&
		   !strcmp(l, "Slots Power")) {
		ads->sens.ops = &smu_slotspow_ops;
		ads->sens.name = "slots-power";
		if (slotspow == NULL) {
			DBG("wf: slotspow partition (%02x) not found\n",
			    SMU_SDB_SLOTSPOW_ID);
			goto fail;
		}
	} else
		goto fail;

	v = of_get_property(node, "reg", NULL);
	if (v == NULL)
		goto fail;
	ads->reg = *v;

	if (wf_register_sensor(&ads->sens))
		goto fail;
	return ads;
 fail:
	kfree(ads);
	return NULL;
}

/*
 * SMU Power combo sensor object
 */

struct smu_cpu_power_sensor {
	struct list_head	link;
	struct wf_sensor	*volts;
	struct wf_sensor	*amps;
	int			fake_volts : 1;
	int			quadratic : 1;
	struct wf_sensor	sens;
};
#define to_smu_cpu_power(c) container_of(c, struct smu_cpu_power_sensor, sens)

static struct smu_cpu_power_sensor *smu_cpu_power;

static void smu_cpu_power_release(struct wf_sensor *sr)
{
	struct smu_cpu_power_sensor *pow = to_smu_cpu_power(sr);

	if (pow->volts)
		wf_put_sensor(pow->volts);
	if (pow->amps)
		wf_put_sensor(pow->amps);
	kfree(pow);
}

static int smu_cpu_power_get(struct wf_sensor *sr, s32 *value)
{
	struct smu_cpu_power_sensor *pow = to_smu_cpu_power(sr);
	s32 volts, amps, power;
	u64 tmps, tmpa, tmpb;
	int rc;

	rc = pow->amps->ops->get_value(pow->amps, &amps);
	if (rc)
		return rc;

	if (pow->fake_volts) {
		*value = amps * 12 - 0x30000;
		return 0;
	}

	rc = pow->volts->ops->get_value(pow->volts, &volts);
	if (rc)
		return rc;

	power = (s32)((((u64)volts) * ((u64)amps)) >> 16);
	if (!pow->quadratic) {
		*value = power;
		return 0;
	}
	tmps = (((u64)power) * ((u64)power)) >> 16;
	tmpa = ((u64)cpuvcp->power_quads[0]) * tmps;
	tmpb = ((u64)cpuvcp->power_quads[1]) * ((u64)power);
	*value = (tmpa >> 28) + (tmpb >> 28) + (cpuvcp->power_quads[2] >> 12);

	return 0;
}

static struct wf_sensor_ops smu_cpu_power_ops = {
	.get_value	= smu_cpu_power_get,
	.release	= smu_cpu_power_release,
	.owner		= THIS_MODULE,
};


static struct smu_cpu_power_sensor *
smu_cpu_power_create(struct wf_sensor *volts, struct wf_sensor *amps)
{
	struct smu_cpu_power_sensor *pow;

	pow = kmalloc(sizeof(struct smu_cpu_power_sensor), GFP_KERNEL);
	if (pow == NULL)
		return NULL;
	pow->sens.ops = &smu_cpu_power_ops;
	pow->sens.name = "cpu-power";

	wf_get_sensor(volts);
	pow->volts = volts;
	wf_get_sensor(amps);
	pow->amps = amps;

	/* Some early machines need a faked voltage */
	if (debugswitches && ((*debugswitches) & 0x80)) {
		printk(KERN_INFO "windfarm: CPU Power sensor using faked"
		       " voltage !\n");
		pow->fake_volts = 1;
	} else
		pow->fake_volts = 0;

	/* Try to use quadratic transforms on PowerMac8,1 and 9,1 for now,
	 * I yet have to figure out what's up with 8,2 and will have to
	 * adjust for later, unless we can 100% trust the SDB partition...
	 */
	if ((of_machine_is_compatible("PowerMac8,1") ||
	     of_machine_is_compatible("PowerMac8,2") ||
	     of_machine_is_compatible("PowerMac9,1")) &&
	    cpuvcp_version >= 2) {
		pow->quadratic = 1;
		DBG("windfarm: CPU Power using quadratic transform\n");
	} else
		pow->quadratic = 0;

	if (wf_register_sensor(&pow->sens))
		goto fail;
	return pow;
 fail:
	kfree(pow);
	return NULL;
}

static void smu_fetch_param_partitions(void)
{
	const struct smu_sdbp_header *hdr;

	/* Get CPU voltage/current/power calibration data */
	hdr = smu_get_sdb_partition(SMU_SDB_CPUVCP_ID, NULL);
	if (hdr != NULL) {
		cpuvcp = (struct smu_sdbp_cpuvcp *)&hdr[1];
		/* Keep version around */
		cpuvcp_version = hdr->version;
	}

	/* Get CPU diode calibration data */
	hdr = smu_get_sdb_partition(SMU_SDB_CPUDIODE_ID, NULL);
	if (hdr != NULL)
		cpudiode = (struct smu_sdbp_cpudiode *)&hdr[1];

	/* Get slots power calibration data if any */
	hdr = smu_get_sdb_partition(SMU_SDB_SLOTSPOW_ID, NULL);
	if (hdr != NULL)
		slotspow = (struct smu_sdbp_slotspow *)&hdr[1];

	/* Get debug switches if any */
	hdr = smu_get_sdb_partition(SMU_SDB_DEBUG_SWITCHES_ID, NULL);
	if (hdr != NULL)
		debugswitches = (u8 *)&hdr[1];
}

static int __init smu_sensors_init(void)
{
	struct device_node *smu, *sensors, *s;
	struct smu_ad_sensor *volt_sensor = NULL, *curr_sensor = NULL;

	if (!smu_present())
		return -ENODEV;

	/* Get parameters partitions */
	smu_fetch_param_partitions();

	smu = of_find_node_by_type(NULL, "smu");
	if (smu == NULL)
		return -ENODEV;

	/* Look for sensors subdir */
	for (sensors = NULL;
	     (sensors = of_get_next_child(smu, sensors)) != NULL;)
		if (!strcmp(sensors->name, "sensors"))
			break;

	of_node_put(smu);

	/* Create basic sensors */
	for (s = NULL;
	     sensors && (s = of_get_next_child(sensors, s)) != NULL;) {
		struct smu_ad_sensor *ads;

		ads = smu_ads_create(s);
		if (ads == NULL)
			continue;
		list_add(&ads->link, &smu_ads);
		/* keep track of cpu voltage & current */
		if (!strcmp(ads->sens.name, "cpu-voltage"))
			volt_sensor = ads;
		else if (!strcmp(ads->sens.name, "cpu-current"))
			curr_sensor = ads;
	}

	of_node_put(sensors);

	/* Create CPU power sensor if possible */
	if (volt_sensor && curr_sensor)
		smu_cpu_power = smu_cpu_power_create(&volt_sensor->sens,
						     &curr_sensor->sens);

	return 0;
}

static void __exit smu_sensors_exit(void)
{
	struct smu_ad_sensor *ads;

	/* dispose of power sensor */
	if (smu_cpu_power)
		wf_unregister_sensor(&smu_cpu_power->sens);

	/* dispose of basic sensors */
	while (!list_empty(&smu_ads)) {
		ads = list_entry(smu_ads.next, struct smu_ad_sensor, link);
		list_del(&ads->link);
		wf_unregister_sensor(&ads->sens);
	}
}


module_init(smu_sensors_init);
module_exit(smu_sensors_exit);

MODULE_AUTHOR("Benjamin Herrenschmidt <benh@kernel.crashing.org>");
MODULE_DESCRIPTION("SMU sensor objects for PowerMacs thermal control");
MODULE_LICENSE("GPL");
Commit	Line	Data
75722d39 BH	1	/*
	2	* Windfarm PowerMac thermal control. SMU based sensors
	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
	10	#include <linux/types.h>
	11	#include <linux/errno.h>
	12	#include <linux/kernel.h>
	13	#include <linux/delay.h>
	14	#include <linux/slab.h>
	15	#include <linux/init.h>
	16	#include <linux/wait.h>
de25968c	17	#include <linux/completion.h>
75722d39 BH	18	#include <asm/prom.h>
	19	#include <asm/machdep.h>
	20	#include <asm/io.h>
	21	#include <asm/system.h>
	22	#include <asm/sections.h>
	23	#include <asm/smu.h>
	24
	25	#include "windfarm.h"
	26
	27	#define VERSION "0.2"
	28
	29	#undef DEBUG
	30
	31	#ifdef DEBUG
	32	#define DBG(args...) printk(args)
	33	#else
	34	#define DBG(args...) do { } while(0)
	35	#endif
	36
	37	/*
	38	* Various SMU "partitions" calibration objects for which we
	39	* keep pointers here for use by bits & pieces of the driver
	40	*/
	41	static struct smu_sdbp_cpuvcp *cpuvcp;
	42	static int cpuvcp_version;
	43	static struct smu_sdbp_cpudiode *cpudiode;
	44	static struct smu_sdbp_slotspow *slotspow;
	45	static u8 *debugswitches;
	46
	47	/*
	48	* SMU basic sensors objects
	49	*/
	50
	51	static LIST_HEAD(smu_ads);
	52
	53	struct smu_ad_sensor {
	54	struct list_head link;
	55	u32 reg; /* index in SMU */
	56	struct wf_sensor sens;
	57	};
	58	#define to_smu_ads(c) container_of(c, struct smu_ad_sensor, sens)
	59
	60	static void smu_ads_release(struct wf_sensor *sr)
	61	{
	62	struct smu_ad_sensor *ads = to_smu_ads(sr);
	63
	64	kfree(ads);
	65	}
	66
	67	static int smu_read_adc(u8 id, s32 *value)
	68	{
	69	struct smu_simple_cmd cmd;
6e9a4738	70	DECLARE_COMPLETION_ONSTACK(comp);
75722d39 BH	71	int rc;
	72
	73	rc = smu_queue_simple(&cmd, SMU_CMD_READ_ADC, 1,
	74	smu_done_complete, &comp, id);
	75	if (rc)
	76	return rc;
	77	wait_for_completion(&comp);
	78	if (cmd.cmd.status != 0)
	79	return cmd.cmd.status;
	80	if (cmd.cmd.reply_len != 2) {
	81	printk(KERN_ERR "winfarm: read ADC 0x%x returned %d bytes !\n",
	82	id, cmd.cmd.reply_len);
	83	return -EIO;
	84	}
	85	value = ((u16 *)cmd.buffer);
	86	return 0;
	87	}
	88
	89	static int smu_cputemp_get(struct wf_sensor sr, s32 value)
	90	{
	91	struct smu_ad_sensor *ads = to_smu_ads(sr);
	92	int rc;
	93	s32 val;
	94	s64 scaled;
	95
	96	rc = smu_read_adc(ads->reg, &val);
	97	if (rc) {
	98	printk(KERN_ERR "windfarm: read CPU temp failed, err %d\n",
	99	rc);
	100	return rc;
	101	}
	102
	103	/* Ok, we have to scale & adjust, taking units into account */
	104	scaled = (s64)(((u64)val) * (u64)cpudiode->m_value);
	105	scaled >>= 3;
	106	scaled += ((s64)cpudiode->b_value) << 9;
	107	*value = (s32)(scaled << 1);
	108
	109	return 0;
	110	}
	111
	112	static int smu_cpuamp_get(struct wf_sensor sr, s32 value)
	113	{
	114	struct smu_ad_sensor *ads = to_smu_ads(sr);
	115	s32 val, scaled;
	116	int rc;
	117
	118	rc = smu_read_adc(ads->reg, &val);
	119	if (rc) {
	120	printk(KERN_ERR "windfarm: read CPU current failed, err %d\n",
	121	rc);
	122	return rc;
	123	}
	124
	125	/* Ok, we have to scale & adjust, taking units into account */
	126	scaled = (s32)(val * (u32)cpuvcp->curr_scale);
	127	scaled += (s32)cpuvcp->curr_offset;
	128	*value = scaled << 4;
	129
	130	return 0;
	131	}
	132
	133	static int smu_cpuvolt_get(struct wf_sensor sr, s32 value)
	134	{
135	struct smu_ad_sensor *ads = to_smu_ads(sr);
136	s32 val, scaled;
137	int rc;
138
139	rc = smu_read_adc(ads->reg, &val);
140	if (rc) {
141	printk(KERN_ERR "windfarm: read CPU voltage failed, err %d\n",
142	rc);
143	return rc;
144	}
145
146	/* Ok, we have to scale & adjust, taking units into account */
147	scaled = (s32)(val * (u32)cpuvcp->volt_scale);
148	scaled += (s32)cpuvcp->volt_offset;
149	*value = scaled << 4;
150
151	return 0;
152	}
153
154	static int smu_slotspow_get(struct wf_sensor sr, s32 value)
155	{
156	struct smu_ad_sensor *ads = to_smu_ads(sr);
157	s32 val, scaled;
158	int rc;
159
160	rc = smu_read_adc(ads->reg, &val);
161	if (rc) {
162	printk(KERN_ERR "windfarm: read slots power failed, err %d\n",
163	rc);
164	return rc;
165	}
166
167	/* Ok, we have to scale & adjust, taking units into account */
168	scaled = (s32)(val * (u32)slotspow->pow_scale);
169	scaled += (s32)slotspow->pow_offset;
170	*value = scaled << 4;
171
172	return 0;
173	}
174
175
176	static struct wf_sensor_ops smu_cputemp_ops = {
177	.get_value = smu_cputemp_get,
178	.release = smu_ads_release,
179	.owner = THIS_MODULE,
180	};
181	static struct wf_sensor_ops smu_cpuamp_ops = {
182	.get_value = smu_cpuamp_get,
183	.release = smu_ads_release,
184	.owner = THIS_MODULE,
185	};
186	static struct wf_sensor_ops smu_cpuvolt_ops = {
187	.get_value = smu_cpuvolt_get,
188	.release = smu_ads_release,
189	.owner = THIS_MODULE,
190	};
191	static struct wf_sensor_ops smu_slotspow_ops = {
192	.get_value = smu_slotspow_get,
193	.release = smu_ads_release,
194	.owner = THIS_MODULE,
195	};
196
197
198	static struct smu_ad_sensor smu_ads_create(struct device_node node)
199	{
200	struct smu_ad_sensor *ads;
018a3d1d JK	201	const char c, l;
018a3d1d JK	202	const u32 *v;
75722d39 BH	203
	204	ads = kmalloc(sizeof(struct smu_ad_sensor), GFP_KERNEL);
	205	if (ads == NULL)
	206	return NULL;
01b2726d SR	207	c = of_get_property(node, "device_type", NULL);
01b2726d SR	208	l = of_get_property(node, "location", NULL);
75722d39 BH	209	if (c == NULL \|\| l == NULL)
	210	goto fail;
	211
	212	/* We currently pick the sensors based on the OF name and location
	213	* properties, while Darwin uses the sensor-id's.
	214	* The problem with the IDs is that they are model specific while it
	215	* looks like apple has been doing a reasonably good job at keeping
	216	* the names and locations consistents so I'll stick with the names
	217	* and locations for now.
	218	*/
	219	if (!strcmp(c, "temp-sensor") &&
	220	!strcmp(l, "CPU T-Diode")) {
	221	ads->sens.ops = &smu_cputemp_ops;
	222	ads->sens.name = "cpu-temp";
ac171c46 BH	223	if (cpudiode == NULL) {
	224	DBG("wf: cpudiode partition (%02x) not found\n",
	225	SMU_SDB_CPUDIODE_ID);
	226	goto fail;
	227	}
75722d39 BH	228	} else if (!strcmp(c, "current-sensor") &&
	229	!strcmp(l, "CPU Current")) {
	230	ads->sens.ops = &smu_cpuamp_ops;
	231	ads->sens.name = "cpu-current";
ac171c46 BH	232	if (cpuvcp == NULL) {
	233	DBG("wf: cpuvcp partition (%02x) not found\n",
	234	SMU_SDB_CPUVCP_ID);
	235	goto fail;
	236	}
75722d39 BH	237	} else if (!strcmp(c, "voltage-sensor") &&
	238	!strcmp(l, "CPU Voltage")) {
	239	ads->sens.ops = &smu_cpuvolt_ops;
	240	ads->sens.name = "cpu-voltage";
ac171c46 BH	241	if (cpuvcp == NULL) {
	242	DBG("wf: cpuvcp partition (%02x) not found\n",
	243	SMU_SDB_CPUVCP_ID);
	244	goto fail;
	245	}
75722d39 BH	246	} else if (!strcmp(c, "power-sensor") &&
	247	!strcmp(l, "Slots Power")) {
	248	ads->sens.ops = &smu_slotspow_ops;
	249	ads->sens.name = "slots-power";
	250	if (slotspow == NULL) {
	251	DBG("wf: slotspow partition (%02x) not found\n",
	252	SMU_SDB_SLOTSPOW_ID);
	253	goto fail;
	254	}
	255	} else
	256	goto fail;
	257
01b2726d	258	v = of_get_property(node, "reg", NULL);
75722d39 BH	259	if (v == NULL)
	260	goto fail;
	261	ads->reg = *v;
	262
	263	if (wf_register_sensor(&ads->sens))
	264	goto fail;
	265	return ads;
	266	fail:
	267	kfree(ads);
	268	return NULL;
	269	}
	270
	271	/*
	272	* SMU Power combo sensor object
	273	*/
	274
	275	struct smu_cpu_power_sensor {
	276	struct list_head link;
	277	struct wf_sensor *volts;
	278	struct wf_sensor *amps;
	279	int fake_volts : 1;
	280	int quadratic : 1;
	281	struct wf_sensor sens;
	282	};
	283	#define to_smu_cpu_power(c) container_of(c, struct smu_cpu_power_sensor, sens)
	284
	285	static struct smu_cpu_power_sensor *smu_cpu_power;
	286
	287	static void smu_cpu_power_release(struct wf_sensor *sr)
	288	{
	289	struct smu_cpu_power_sensor *pow = to_smu_cpu_power(sr);
	290
	291	if (pow->volts)
	292	wf_put_sensor(pow->volts);
	293	if (pow->amps)
	294	wf_put_sensor(pow->amps);
	295	kfree(pow);
	296	}
	297
	298	static int smu_cpu_power_get(struct wf_sensor sr, s32 value)
	299	{
	300	struct smu_cpu_power_sensor *pow = to_smu_cpu_power(sr);
	301	s32 volts, amps, power;
	302	u64 tmps, tmpa, tmpb;
	303	int rc;
	304
	305	rc = pow->amps->ops->get_value(pow->amps, &amps);
	306	if (rc)
	307	return rc;
	308
	309	if (pow->fake_volts) {
	310	value = amps 12 - 0x30000;
	311	return 0;
	312	}
	313
	314	rc = pow->volts->ops->get_value(pow->volts, &volts);
	315	if (rc)
	316	return rc;
	317
	318	power = (s32)((((u64)volts) * ((u64)amps)) >> 16);
	319	if (!pow->quadratic) {
	320	*value = power;
	321	return 0;
	322	}
323	tmps = (((u64)power) * ((u64)power)) >> 16;
324	tmpa = ((u64)cpuvcp->power_quads[0]) * tmps;
325	tmpb = ((u64)cpuvcp->power_quads[1]) * ((u64)power);
326	*value = (tmpa >> 28) + (tmpb >> 28) + (cpuvcp->power_quads[2] >> 12);
327
328	return 0;
329	}
330
331	static struct wf_sensor_ops smu_cpu_power_ops = {
332	.get_value = smu_cpu_power_get,
333	.release = smu_cpu_power_release,
334	.owner = THIS_MODULE,
335	};
336
337
338	static struct smu_cpu_power_sensor *
339	smu_cpu_power_create(struct wf_sensor volts, struct wf_sensor amps)
340	{
341	struct smu_cpu_power_sensor *pow;
342
343	pow = kmalloc(sizeof(struct smu_cpu_power_sensor), GFP_KERNEL);
344	if (pow == NULL)
345	return NULL;
346	pow->sens.ops = &smu_cpu_power_ops;
347	pow->sens.name = "cpu-power";
348
349	wf_get_sensor(volts);
350	pow->volts = volts;
351	wf_get_sensor(amps);
352	pow->amps = amps;
353
354	/* Some early machines need a faked voltage */
355	if (debugswitches && ((*debugswitches) & 0x80)) {
356	printk(KERN_INFO "windfarm: CPU Power sensor using faked"
357	" voltage !\n");
358	pow->fake_volts = 1;
359	} else
360	pow->fake_volts = 0;
361
362	/* Try to use quadratic transforms on PowerMac8,1 and 9,1 for now,
363	* I yet have to figure out what's up with 8,2 and will have to
364	* adjust for later, unless we can 100% trust the SDB partition...
365	*/
71a157e8 GL	366	if ((of_machine_is_compatible("PowerMac8,1") \|\|
	367	of_machine_is_compatible("PowerMac8,2") \|\|
	368	of_machine_is_compatible("PowerMac9,1")) &&
75722d39 BH	369	cpuvcp_version >= 2) {
	370	pow->quadratic = 1;
	371	DBG("windfarm: CPU Power using quadratic transform\n");
	372	} else
	373	pow->quadratic = 0;
	374
	375	if (wf_register_sensor(&pow->sens))
	376	goto fail;
	377	return pow;
	378	fail:
	379	kfree(pow);
	380	return NULL;
	381	}
	382
ac171c46	383	static void smu_fetch_param_partitions(void)
75722d39	384	{
018a3d1d	385	const struct smu_sdbp_header *hdr;
75722d39 BH	386
	387	/* Get CPU voltage/current/power calibration data */
	388	hdr = smu_get_sdb_partition(SMU_SDB_CPUVCP_ID, NULL);
ac171c46 BH	389	if (hdr != NULL) {
	390	cpuvcp = (struct smu_sdbp_cpuvcp *)&hdr[1];
	391	/* Keep version around */
	392	cpuvcp_version = hdr->version;
75722d39	393	}
75722d39 BH	394
	395	/* Get CPU diode calibration data */
	396	hdr = smu_get_sdb_partition(SMU_SDB_CPUDIODE_ID, NULL);
ac171c46 BH	397	if (hdr != NULL)
ac171c46 BH	398	cpudiode = (struct smu_sdbp_cpudiode *)&hdr[1];
75722d39 BH	399
	400	/* Get slots power calibration data if any */
	401	hdr = smu_get_sdb_partition(SMU_SDB_SLOTSPOW_ID, NULL);
	402	if (hdr != NULL)
	403	slotspow = (struct smu_sdbp_slotspow *)&hdr[1];
	404
	405	/* Get debug switches if any */
	406	hdr = smu_get_sdb_partition(SMU_SDB_DEBUG_SWITCHES_ID, NULL);
	407	if (hdr != NULL)
	408	debugswitches = (u8 *)&hdr[1];
75722d39 BH	409	}
	410
	411	static int __init smu_sensors_init(void)
	412	{
	413	struct device_node smu, sensors, *s;
	414	struct smu_ad_sensor volt_sensor = NULL, curr_sensor = NULL;
75722d39 BH	415
	416	if (!smu_present())
	417	return -ENODEV;
	418
	419	/* Get parameters partitions */
ac171c46	420	smu_fetch_param_partitions();
75722d39 BH	421
	422	smu = of_find_node_by_type(NULL, "smu");
	423	if (smu == NULL)
	424	return -ENODEV;
	425
	426	/* Look for sensors subdir */
	427	for (sensors = NULL;
	428	(sensors = of_get_next_child(smu, sensors)) != NULL;)
	429	if (!strcmp(sensors->name, "sensors"))
	430	break;
	431
	432	of_node_put(smu);
	433
	434	/* Create basic sensors */
	435	for (s = NULL;
	436	sensors && (s = of_get_next_child(sensors, s)) != NULL;) {
	437	struct smu_ad_sensor *ads;
	438
	439	ads = smu_ads_create(s);
	440	if (ads == NULL)
	441	continue;
	442	list_add(&ads->link, &smu_ads);
	443	/* keep track of cpu voltage & current */
	444	if (!strcmp(ads->sens.name, "cpu-voltage"))
	445	volt_sensor = ads;
	446	else if (!strcmp(ads->sens.name, "cpu-current"))
	447	curr_sensor = ads;
	448	}
	449
	450	of_node_put(sensors);
	451
	452	/* Create CPU power sensor if possible */
	453	if (volt_sensor && curr_sensor)
	454	smu_cpu_power = smu_cpu_power_create(&volt_sensor->sens,
	455	&curr_sensor->sens);
	456
	457	return 0;
	458	}
	459
	460	static void __exit smu_sensors_exit(void)
	461	{
	462	struct smu_ad_sensor *ads;
	463
	464	/* dispose of power sensor */
	465	if (smu_cpu_power)
	466	wf_unregister_sensor(&smu_cpu_power->sens);
	467
	468	/* dispose of basic sensors */
	469	while (!list_empty(&smu_ads)) {
	470	ads = list_entry(smu_ads.next, struct smu_ad_sensor, link);
	471	list_del(&ads->link);
	472	wf_unregister_sensor(&ads->sens);
	473	}
	474	}
	475
	476
	477	module_init(smu_sensors_init);
	478	module_exit(smu_sensors_exit);
	479
	480	MODULE_AUTHOR("Benjamin Herrenschmidt <benh@kernel.crashing.org>");
	481	MODULE_DESCRIPTION("SMU sensor objects for PowerMacs thermal control");
	482	MODULE_LICENSE("GPL");
	483