[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / macintosh / windfarm_ad7417_sensor.c

/*
 * Windfarm PowerMac thermal control. AD7417 sensors
 *
 * Copyright 2012 Benjamin Herrenschmidt, IBM Corp.
 *
 * 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/i2c.h>
#include <asm/prom.h>
#include <asm/machdep.h>
#include <asm/io.h>
#include <asm/sections.h>

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

#define VERSION "1.0"

struct wf_ad7417_priv {
	struct kref		ref;
	struct i2c_client	*i2c;
	u8			config;
	u8			cpu;
	const struct mpu_data	*mpu;
	struct wf_sensor	sensors[5];
	struct mutex		lock;
};

static int wf_ad7417_temp_get(struct wf_sensor *sr, s32 *value)
{
	struct wf_ad7417_priv *pv = sr->priv;
	u8 buf[2];
	s16 raw;
	int rc;

	*value = 0;
	mutex_lock(&pv->lock);

	/* Read temp register */
	buf[0] = 0;
	rc = i2c_master_send(pv->i2c, buf, 1);
	if (rc < 0)
		goto error;
	rc = i2c_master_recv(pv->i2c, buf, 2);
	if (rc < 0)
		goto error;

	/* Read a a 16-bit signed value */
	raw = be16_to_cpup((__le16 *)buf);

	/* Convert 8.8-bit to 16.16 fixed point */
	*value = ((s32)raw) << 8;

	mutex_unlock(&pv->lock);
	return 0;

error:
	mutex_unlock(&pv->lock);
	return -1;
}

/*
 * Scaling factors for the AD7417 ADC converters (except
 * for the CPU diode which is obtained from the EEPROM).
 * Those values are obtained from the property list of
 * the darwin driver
 */
#define ADC_12V_CURRENT_SCALE	0x0320	/* _AD2 */
#define ADC_CPU_VOLTAGE_SCALE	0x00a0	/* _AD3 */
#define ADC_CPU_CURRENT_SCALE	0x1f40	/* _AD4 */

static void wf_ad7417_adc_convert(struct wf_ad7417_priv *pv,
				  int chan, s32 raw, s32 *value)
{
	switch(chan) {
	case 1: /* Diode */
		*value = (raw * (s32)pv->mpu->mdiode +
			((s32)pv->mpu->bdiode << 12)) >> 2;
		break;
	case 2: /* 12v current */
		*value = raw * ADC_12V_CURRENT_SCALE;
		break;
	case 3: /* core voltage */
		*value = raw * ADC_CPU_VOLTAGE_SCALE;
		break;
	case 4: /* core current */
		*value = raw * ADC_CPU_CURRENT_SCALE;
		break;
	}
}

static int wf_ad7417_adc_get(struct wf_sensor *sr, s32 *value)
{
	struct wf_ad7417_priv *pv = sr->priv;
	int chan = sr - pv->sensors;
	int i, rc;
	u8 buf[2];
	u16 raw;

	*value = 0;
	mutex_lock(&pv->lock);
	for (i = 0; i < 10; i++) {
		/* Set channel */
		buf[0] = 1;
		buf[1] = (pv->config & 0x1f) | (chan << 5);
		rc = i2c_master_send(pv->i2c, buf, 2);
		if (rc < 0)
			goto error;

		/* Wait for conversion */
		msleep(1);

		/* Switch to data register */
		buf[0] = 4;
		rc = i2c_master_send(pv->i2c, buf, 1);
		if (rc < 0)
			goto error;

		/* Read result */
		rc = i2c_master_recv(pv->i2c, buf, 2);
		if (rc < 0)
			goto error;

		/* Read a a 16-bit signed value */
		raw = be16_to_cpup((__le16 *)buf) >> 6;
		wf_ad7417_adc_convert(pv, chan, raw, value);

		dev_vdbg(&pv->i2c->dev, "ADC chan %d [%s]"
			 " raw value: 0x%x, conv to: 0x%08x\n",
			 chan, sr->name, raw, *value);

		mutex_unlock(&pv->lock);
		return 0;

	error:
		dev_dbg(&pv->i2c->dev,
			  "Error reading ADC, try %d...\n", i);
		if (i < 9)
			msleep(10);
	}
	mutex_unlock(&pv->lock);
	return -1;
}

static void wf_ad7417_release(struct kref *ref)
{
	struct wf_ad7417_priv *pv = container_of(ref,
						 struct wf_ad7417_priv, ref);
	kfree(pv);
}

static void wf_ad7417_sensor_release(struct wf_sensor *sr)
{
	struct wf_ad7417_priv *pv = sr->priv;

	kfree(sr->name);
	kref_put(&pv->ref, wf_ad7417_release);
}

static const struct wf_sensor_ops wf_ad7417_temp_ops = {
	.get_value	= wf_ad7417_temp_get,
	.release	= wf_ad7417_sensor_release,
	.owner		= THIS_MODULE,
};

static const struct wf_sensor_ops wf_ad7417_adc_ops = {
	.get_value	= wf_ad7417_adc_get,
	.release	= wf_ad7417_sensor_release,
	.owner		= THIS_MODULE,
};

static void wf_ad7417_add_sensor(struct wf_ad7417_priv *pv,
				 int index, const char *name,
				 const struct wf_sensor_ops *ops)
{
	pv->sensors[index].name = kasprintf(GFP_KERNEL, "%s-%d", name, pv->cpu);
	pv->sensors[index].priv = pv;
	pv->sensors[index].ops = ops;
	if (!wf_register_sensor(&pv->sensors[index]))
		kref_get(&pv->ref);
}

static void wf_ad7417_init_chip(struct wf_ad7417_priv *pv)
{
	int rc;
	u8 buf[2];
	u8 config = 0;

	/*
	 * Read ADC the configuration register and cache it. We
	 * also make sure Config2 contains proper values, I've seen
	 * cases where we got stale grabage in there, thus preventing
	 * proper reading of conv. values
	 */

	/* Clear Config2 */
	buf[0] = 5;
	buf[1] = 0;
	i2c_master_send(pv->i2c, buf, 2);

	/* Read & cache Config1 */
	buf[0] = 1;
	rc = i2c_master_send(pv->i2c, buf, 1);
	if (rc > 0) {
		rc = i2c_master_recv(pv->i2c, buf, 1);
		if (rc > 0) {
			config = buf[0];

			dev_dbg(&pv->i2c->dev, "ADC config reg: %02x\n",
				config);

			/* Disable shutdown mode */
			config &= 0xfe;
			buf[0] = 1;
			buf[1] = config;
			rc = i2c_master_send(pv->i2c, buf, 2);
		}
	}
	if (rc <= 0)
		dev_err(&pv->i2c->dev, "Error reading ADC config\n");

	pv->config = config;
}

static int wf_ad7417_probe(struct i2c_client *client,
			   const struct i2c_device_id *id)
{
	struct wf_ad7417_priv *pv;
	const struct mpu_data *mpu;
	const char *loc;
	int cpu_nr;

	loc = of_get_property(client->dev.of_node, "hwsensor-location", NULL);
	if (!loc) {
		dev_warn(&client->dev, "Missing hwsensor-location property!\n");
		return -ENXIO;
	}

	/*
	 * Identify which CPU we belong to by looking at the first entry
	 * in the hwsensor-location list
	 */
	if (!strncmp(loc, "CPU A", 5))
		cpu_nr = 0;
	else if (!strncmp(loc, "CPU B", 5))
		cpu_nr = 1;
	else {
		pr_err("wf_ad7417: Can't identify location %s\n", loc);
		return -ENXIO;
	}
	mpu = wf_get_mpu(cpu_nr);
	if (!mpu) {
		dev_err(&client->dev, "Failed to retrieve MPU data\n");
		return -ENXIO;
	}

	pv = kzalloc(sizeof(struct wf_ad7417_priv), GFP_KERNEL);
	if (pv == NULL)
		return -ENODEV;

	kref_init(&pv->ref);
	mutex_init(&pv->lock);
	pv->i2c = client;
	pv->cpu = cpu_nr;
	pv->mpu = mpu;
	dev_set_drvdata(&client->dev, pv);

	/* Initialize the chip */
	wf_ad7417_init_chip(pv);

	/*
	 * We cannot rely on Apple device-tree giving us child
	 * node with the names of the individual sensors so we
	 * just hard code what we know about them
	 */
	wf_ad7417_add_sensor(pv, 0, "cpu-amb-temp", &wf_ad7417_temp_ops);
	wf_ad7417_add_sensor(pv, 1, "cpu-diode-temp", &wf_ad7417_adc_ops);
	wf_ad7417_add_sensor(pv, 2, "cpu-12v-current", &wf_ad7417_adc_ops);
	wf_ad7417_add_sensor(pv, 3, "cpu-voltage", &wf_ad7417_adc_ops);
	wf_ad7417_add_sensor(pv, 4, "cpu-current", &wf_ad7417_adc_ops);

	return 0;
}

static int wf_ad7417_remove(struct i2c_client *client)
{
	struct wf_ad7417_priv *pv = dev_get_drvdata(&client->dev);
	int i;

	/* Mark client detached */
	pv->i2c = NULL;

	/* Release sensor */
	for (i = 0; i < 5; i++)
		wf_unregister_sensor(&pv->sensors[i]);

	kref_put(&pv->ref, wf_ad7417_release);

	return 0;
}

static const struct i2c_device_id wf_ad7417_id[] = {
	{ "MAC,ad7417", 0 },
	{ }
};
MODULE_DEVICE_TABLE(i2c, wf_ad7417_id);

static struct i2c_driver wf_ad7417_driver = {
	.driver = {
		.name	= "wf_ad7417",
	},
	.probe		= wf_ad7417_probe,
	.remove		= wf_ad7417_remove,
	.id_table	= wf_ad7417_id,
};

static int wf_ad7417_init(void)
{
	/* This is only supported on these machines */
	if (!of_machine_is_compatible("PowerMac7,2") &&
	    !of_machine_is_compatible("PowerMac7,3") &&
	    !of_machine_is_compatible("RackMac3,1"))
		return -ENODEV;

	return i2c_add_driver(&wf_ad7417_driver);
}

static void wf_ad7417_exit(void)
{
	i2c_del_driver(&wf_ad7417_driver);
}

module_init(wf_ad7417_init);
module_exit(wf_ad7417_exit);

MODULE_AUTHOR("Benjamin Herrenschmidt <benh@kernel.crashing.org>");
MODULE_DESCRIPTION("ad7417 sensor driver for PowerMacs");
MODULE_LICENSE("GPL");
Commit	Line	Data
850dc321 BH	1	/*
	2	* Windfarm PowerMac thermal control. AD7417 sensors
	3	*
	4	* Copyright 2012 Benjamin Herrenschmidt, IBM Corp.
	5	*
	6	* Released under the term of the GNU GPL v2.
	7	*/
	8
	9	#include <linux/types.h>
	10	#include <linux/errno.h>
	11	#include <linux/kernel.h>
	12	#include <linux/delay.h>
	13	#include <linux/slab.h>
	14	#include <linux/init.h>
	15	#include <linux/wait.h>
	16	#include <linux/i2c.h>
	17	#include <asm/prom.h>
	18	#include <asm/machdep.h>
	19	#include <asm/io.h>
	20	#include <asm/sections.h>
	21
	22	#include "windfarm.h"
	23	#include "windfarm_mpu.h"
	24
	25	#define VERSION "1.0"
	26
	27	struct wf_ad7417_priv {
	28	struct kref ref;
	29	struct i2c_client *i2c;
	30	u8 config;
	31	u8 cpu;
	32	const struct mpu_data *mpu;
	33	struct wf_sensor sensors[5];
	34	struct mutex lock;
	35	};
	36
	37	static int wf_ad7417_temp_get(struct wf_sensor sr, s32 value)
	38	{
	39	struct wf_ad7417_priv *pv = sr->priv;
	40	u8 buf[2];
	41	s16 raw;
	42	int rc;
	43
	44	*value = 0;
	45	mutex_lock(&pv->lock);
	46
	47	/* Read temp register */
	48	buf[0] = 0;
	49	rc = i2c_master_send(pv->i2c, buf, 1);
	50	if (rc < 0)
	51	goto error;
	52	rc = i2c_master_recv(pv->i2c, buf, 2);
	53	if (rc < 0)
	54	goto error;
	55
	56	/* Read a a 16-bit signed value */
	57	raw = be16_to_cpup((__le16 *)buf);
	58
	59	/* Convert 8.8-bit to 16.16 fixed point */
	60	*value = ((s32)raw) << 8;
	61
	62	mutex_unlock(&pv->lock);
	63	return 0;
	64
65	error:
66	mutex_unlock(&pv->lock);
67	return -1;
68	}
69
70	/*
71	* Scaling factors for the AD7417 ADC converters (except
72	* for the CPU diode which is obtained from the EEPROM).
73	* Those values are obtained from the property list of
74	* the darwin driver
75	*/
76	#define ADC_12V_CURRENT_SCALE 0x0320 /* _AD2 */
77	#define ADC_CPU_VOLTAGE_SCALE 0x00a0 /* _AD3 */
78	#define ADC_CPU_CURRENT_SCALE 0x1f40 /* _AD4 */
79
80	static void wf_ad7417_adc_convert(struct wf_ad7417_priv *pv,
81	int chan, s32 raw, s32 *value)
82	{
83	switch(chan) {
84	case 1: /* Diode */
85	value = (raw (s32)pv->mpu->mdiode +
86	((s32)pv->mpu->bdiode << 12)) >> 2;
87	break;
88	case 2: /* 12v current */
89	value = raw ADC_12V_CURRENT_SCALE;
90	break;
91	case 3: /* core voltage */
92	value = raw ADC_CPU_VOLTAGE_SCALE;
93	break;
94	case 4: /* core current */
95	value = raw ADC_CPU_CURRENT_SCALE;
96	break;
97	}
98	}
99
100	static int wf_ad7417_adc_get(struct wf_sensor sr, s32 value)
101	{
102	struct wf_ad7417_priv *pv = sr->priv;
103	int chan = sr - pv->sensors;
104	int i, rc;
105	u8 buf[2];
106	u16 raw;
107
108	*value = 0;
109	mutex_lock(&pv->lock);
110	for (i = 0; i < 10; i++) {
111	/* Set channel */
112	buf[0] = 1;
113	buf[1] = (pv->config & 0x1f) \| (chan << 5);
114	rc = i2c_master_send(pv->i2c, buf, 2);
115	if (rc < 0)
116	goto error;
117
118	/* Wait for conversion */
119	msleep(1);
120
121	/* Switch to data register */
122	buf[0] = 4;
123	rc = i2c_master_send(pv->i2c, buf, 1);
124	if (rc < 0)
125	goto error;
126
127	/* Read result */
128	rc = i2c_master_recv(pv->i2c, buf, 2);
129	if (rc < 0)
130	goto error;
131
132	/* Read a a 16-bit signed value */
133	raw = be16_to_cpup((__le16 *)buf) >> 6;
134	wf_ad7417_adc_convert(pv, chan, raw, value);
135
136	dev_vdbg(&pv->i2c->dev, "ADC chan %d [%s]"
137	" raw value: 0x%x, conv to: 0x%08x\n",
138	chan, sr->name, raw, *value);
139
140	mutex_unlock(&pv->lock);
141	return 0;
142
143	error:
144	dev_dbg(&pv->i2c->dev,
145	"Error reading ADC, try %d...\n", i);
146	if (i < 9)
147	msleep(10);
148	}
149	mutex_unlock(&pv->lock);
150	return -1;
151	}
152
153	static void wf_ad7417_release(struct kref *ref)
154	{
155	struct wf_ad7417_priv *pv = container_of(ref,
156	struct wf_ad7417_priv, ref);
157	kfree(pv);
158	}
159
160	static void wf_ad7417_sensor_release(struct wf_sensor *sr)
161	{
162	struct wf_ad7417_priv *pv = sr->priv;
163
164	kfree(sr->name);
165	kref_put(&pv->ref, wf_ad7417_release);
166	}
167
168	static const struct wf_sensor_ops wf_ad7417_temp_ops = {
169	.get_value = wf_ad7417_temp_get,
170	.release = wf_ad7417_sensor_release,
171	.owner = THIS_MODULE,
172	};
173
174	static const struct wf_sensor_ops wf_ad7417_adc_ops = {
175	.get_value = wf_ad7417_adc_get,
176	.release = wf_ad7417_sensor_release,
177	.owner = THIS_MODULE,
178	};
179
1da42fb6 GKH	180	static void wf_ad7417_add_sensor(struct wf_ad7417_priv *pv,
	181	int index, const char *name,
	182	const struct wf_sensor_ops *ops)
850dc321 BH	183	{
	184	pv->sensors[index].name = kasprintf(GFP_KERNEL, "%s-%d", name, pv->cpu);
	185	pv->sensors[index].priv = pv;
	186	pv->sensors[index].ops = ops;
	187	if (!wf_register_sensor(&pv->sensors[index]))
	188	kref_get(&pv->ref);
	189	}
	190
1da42fb6	191	static void wf_ad7417_init_chip(struct wf_ad7417_priv *pv)
850dc321 BH	192	{
	193	int rc;
	194	u8 buf[2];
	195	u8 config = 0;
	196
	197	/*
	198	* Read ADC the configuration register and cache it. We
	199	* also make sure Config2 contains proper values, I've seen
	200	* cases where we got stale grabage in there, thus preventing
	201	* proper reading of conv. values
	202	*/
	203
	204	/* Clear Config2 */
	205	buf[0] = 5;
	206	buf[1] = 0;
	207	i2c_master_send(pv->i2c, buf, 2);
	208
	209	/* Read & cache Config1 */
	210	buf[0] = 1;
	211	rc = i2c_master_send(pv->i2c, buf, 1);
	212	if (rc > 0) {
	213	rc = i2c_master_recv(pv->i2c, buf, 1);
	214	if (rc > 0) {
	215	config = buf[0];
	216
	217	dev_dbg(&pv->i2c->dev, "ADC config reg: %02x\n",
	218	config);
	219
	220	/* Disable shutdown mode */
	221	config &= 0xfe;
	222	buf[0] = 1;
	223	buf[1] = config;
	224	rc = i2c_master_send(pv->i2c, buf, 2);
	225	}
	226	}
	227	if (rc <= 0)
	228	dev_err(&pv->i2c->dev, "Error reading ADC config\n");
	229
	230	pv->config = config;
	231	}
	232
1da42fb6 GKH	233	static int wf_ad7417_probe(struct i2c_client *client,
1da42fb6 GKH	234	const struct i2c_device_id *id)
850dc321 BH	235	{
	236	struct wf_ad7417_priv *pv;
	237	const struct mpu_data *mpu;
	238	const char *loc;
	239	int cpu_nr;
	240
	241	loc = of_get_property(client->dev.of_node, "hwsensor-location", NULL);
	242	if (!loc) {
	243	dev_warn(&client->dev, "Missing hwsensor-location property!\n");
	244	return -ENXIO;
	245	}
	246
	247	/*
	248	* Identify which CPU we belong to by looking at the first entry
	249	* in the hwsensor-location list
	250	*/
	251	if (!strncmp(loc, "CPU A", 5))
	252	cpu_nr = 0;
	253	else if (!strncmp(loc, "CPU B", 5))
	254	cpu_nr = 1;
	255	else {
	256	pr_err("wf_ad7417: Can't identify location %s\n", loc);
	257	return -ENXIO;
	258	}
	259	mpu = wf_get_mpu(cpu_nr);
	260	if (!mpu) {
	261	dev_err(&client->dev, "Failed to retrieve MPU data\n");
	262	return -ENXIO;
	263	}
	264
	265	pv = kzalloc(sizeof(struct wf_ad7417_priv), GFP_KERNEL);
	266	if (pv == NULL)
	267	return -ENODEV;
	268
	269	kref_init(&pv->ref);
	270	mutex_init(&pv->lock);
	271	pv->i2c = client;
	272	pv->cpu = cpu_nr;
	273	pv->mpu = mpu;
	274	dev_set_drvdata(&client->dev, pv);
	275
	276	/* Initialize the chip */
	277	wf_ad7417_init_chip(pv);
	278
	279	/*
	280	* We cannot rely on Apple device-tree giving us child
	281	* node with the names of the individual sensors so we
	282	* just hard code what we know about them
	283	*/
	284	wf_ad7417_add_sensor(pv, 0, "cpu-amb-temp", &wf_ad7417_temp_ops);
	285	wf_ad7417_add_sensor(pv, 1, "cpu-diode-temp", &wf_ad7417_adc_ops);
	286	wf_ad7417_add_sensor(pv, 2, "cpu-12v-current", &wf_ad7417_adc_ops);
	287	wf_ad7417_add_sensor(pv, 3, "cpu-voltage", &wf_ad7417_adc_ops);
	288	wf_ad7417_add_sensor(pv, 4, "cpu-current", &wf_ad7417_adc_ops);
	289
	290	return 0;
	291	}
	292
1da42fb6	293	static int wf_ad7417_remove(struct i2c_client *client)
850dc321 BH	294	{
	295	struct wf_ad7417_priv *pv = dev_get_drvdata(&client->dev);
	296	int i;
	297
	298	/* Mark client detached */
	299	pv->i2c = NULL;
	300
	301	/* Release sensor */
	302	for (i = 0; i < 5; i++)
	303	wf_unregister_sensor(&pv->sensors[i]);
	304
	305	kref_put(&pv->ref, wf_ad7417_release);
	306
	307	return 0;
	308	}
	309
	310	static const struct i2c_device_id wf_ad7417_id[] = {
	311	{ "MAC,ad7417", 0 },
	312	{ }
	313	};
	314	MODULE_DEVICE_TABLE(i2c, wf_ad7417_id);
	315
	316	static struct i2c_driver wf_ad7417_driver = {
	317	.driver = {
	318	.name = "wf_ad7417",
	319	},
	320	.probe = wf_ad7417_probe,
	321	.remove = wf_ad7417_remove,
	322	.id_table = wf_ad7417_id,
	323	};
	324
1da42fb6	325	static int wf_ad7417_init(void)
850dc321 BH	326	{
	327	/* This is only supported on these machines */
	328	if (!of_machine_is_compatible("PowerMac7,2") &&
	329	!of_machine_is_compatible("PowerMac7,3") &&
	330	!of_machine_is_compatible("RackMac3,1"))
	331	return -ENODEV;
	332
	333	return i2c_add_driver(&wf_ad7417_driver);
	334	}
	335
1da42fb6	336	static void wf_ad7417_exit(void)
850dc321 BH	337	{
	338	i2c_del_driver(&wf_ad7417_driver);
	339	}
	340
	341	module_init(wf_ad7417_init);
	342	module_exit(wf_ad7417_exit);
	343
	344	MODULE_AUTHOR("Benjamin Herrenschmidt <benh@kernel.crashing.org>");
	345	MODULE_DESCRIPTION("ad7417 sensor driver for PowerMacs");
	346	MODULE_LICENSE("GPL");
	347