[linux-2.6-block.git] / drivers / hwmon / ads7828.c

/*
 * ads7828.c - driver for TI ADS7828 8-channel A/D converter and compatibles
 * (C) 2007 EADS Astrium
 *
 * This driver is based on the lm75 and other lm_sensors/hwmon drivers
 *
 * Written by Steve Hardy <shardy@redhat.com>
 *
 * ADS7830 support, by Guillaume Roguez <guillaume.roguez@savoirfairelinux.com>
 *
 * For further information, see the Documentation/hwmon/ads7828 file.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

#include <linux/err.h>
#include <linux/hwmon.h>
#include <linux/hwmon-sysfs.h>
#include <linux/i2c.h>
#include <linux/init.h>
#include <linux/jiffies.h>
#include <linux/module.h>
#include <linux/mutex.h>
#include <linux/platform_data/ads7828.h>
#include <linux/slab.h>

/* The ADS7828 registers */
#define ADS7828_NCH		8	/* 8 channels supported */
#define ADS7828_CMD_SD_SE	0x80	/* Single ended inputs */
#define ADS7828_CMD_PD1		0x04	/* Internal vref OFF && A/D ON */
#define ADS7828_CMD_PD3		0x0C	/* Internal vref ON && A/D ON */
#define ADS7828_INT_VREF_MV	2500	/* Internal vref is 2.5V, 2500mV */
#define ADS7828_EXT_VREF_MV_MIN	50	/* External vref min value 0.05V */
#define ADS7828_EXT_VREF_MV_MAX	5250	/* External vref max value 5.25V */

/* List of supported devices */
enum ads7828_chips { ads7828, ads7830 };

/* Client specific data */
struct ads7828_data {
	struct i2c_client *client;
	struct mutex update_lock;	/* Mutex protecting updates */
	unsigned long last_updated;	/* Last updated time (in jiffies) */
	u16 adc_input[ADS7828_NCH];	/* ADS7828_NCH samples */
	bool valid;			/* Validity flag */
	bool diff_input;		/* Differential input */
	bool ext_vref;			/* External voltage reference */
	unsigned int vref_mv;		/* voltage reference value */
	u8 cmd_byte;			/* Command byte without channel bits */
	unsigned int lsb_resol;		/* Resolution of the ADC sample LSB */
	s32 (*read_channel)(const struct i2c_client *client, u8 command);
};

/* Command byte C2,C1,C0 - see datasheet */
static inline u8 ads7828_cmd_byte(u8 cmd, int ch)
{
	return cmd | (((ch >> 1) | (ch & 0x01) << 2) << 4);
}

/* Update data for the device (all 8 channels) */
static struct ads7828_data *ads7828_update_device(struct device *dev)
{
	struct ads7828_data *data = dev_get_drvdata(dev);
	struct i2c_client *client = data->client;

	mutex_lock(&data->update_lock);

	if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
			|| !data->valid) {
		unsigned int ch;
		dev_dbg(&client->dev, "Starting ads7828 update\n");

		for (ch = 0; ch < ADS7828_NCH; ch++) {
			u8 cmd = ads7828_cmd_byte(data->cmd_byte, ch);
			data->adc_input[ch] = data->read_channel(client, cmd);
		}
		data->last_updated = jiffies;
		data->valid = true;
	}

	mutex_unlock(&data->update_lock);

	return data;
}

/* sysfs callback function */
static ssize_t ads7828_show_in(struct device *dev, struct device_attribute *da,
			       char *buf)
{
	struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
	struct ads7828_data *data = ads7828_update_device(dev);
	unsigned int value = DIV_ROUND_CLOSEST(data->adc_input[attr->index] *
					       data->lsb_resol, 1000);

	return sprintf(buf, "%d\n", value);
}

static SENSOR_DEVICE_ATTR(in0_input, S_IRUGO, ads7828_show_in, NULL, 0);
static SENSOR_DEVICE_ATTR(in1_input, S_IRUGO, ads7828_show_in, NULL, 1);
static SENSOR_DEVICE_ATTR(in2_input, S_IRUGO, ads7828_show_in, NULL, 2);
static SENSOR_DEVICE_ATTR(in3_input, S_IRUGO, ads7828_show_in, NULL, 3);
static SENSOR_DEVICE_ATTR(in4_input, S_IRUGO, ads7828_show_in, NULL, 4);
static SENSOR_DEVICE_ATTR(in5_input, S_IRUGO, ads7828_show_in, NULL, 5);
static SENSOR_DEVICE_ATTR(in6_input, S_IRUGO, ads7828_show_in, NULL, 6);
static SENSOR_DEVICE_ATTR(in7_input, S_IRUGO, ads7828_show_in, NULL, 7);

static struct attribute *ads7828_attrs[] = {
	&sensor_dev_attr_in0_input.dev_attr.attr,
	&sensor_dev_attr_in1_input.dev_attr.attr,
	&sensor_dev_attr_in2_input.dev_attr.attr,
	&sensor_dev_attr_in3_input.dev_attr.attr,
	&sensor_dev_attr_in4_input.dev_attr.attr,
	&sensor_dev_attr_in5_input.dev_attr.attr,
	&sensor_dev_attr_in6_input.dev_attr.attr,
	&sensor_dev_attr_in7_input.dev_attr.attr,
	NULL
};

ATTRIBUTE_GROUPS(ads7828);

static int ads7828_probe(struct i2c_client *client,
			 const struct i2c_device_id *id)
{
	struct device *dev = &client->dev;
	struct ads7828_platform_data *pdata = dev_get_platdata(dev);
	struct ads7828_data *data;
	struct device *hwmon_dev;

	data = devm_kzalloc(dev, sizeof(struct ads7828_data), GFP_KERNEL);
	if (!data)
		return -ENOMEM;

	if (pdata) {
		data->diff_input = pdata->diff_input;
		data->ext_vref = pdata->ext_vref;
		if (data->ext_vref)
			data->vref_mv = pdata->vref_mv;
	}

	/* Bound Vref with min/max values if it was provided */
	if (data->vref_mv)
		data->vref_mv = clamp_val(data->vref_mv,
					  ADS7828_EXT_VREF_MV_MIN,
					  ADS7828_EXT_VREF_MV_MAX);
	else
		data->vref_mv = ADS7828_INT_VREF_MV;

	/* ADS7828 uses 12-bit samples, while ADS7830 is 8-bit */
	if (id->driver_data == ads7828) {
		data->lsb_resol = DIV_ROUND_CLOSEST(data->vref_mv * 1000, 4096);
		data->read_channel = i2c_smbus_read_word_swapped;
	} else {
		data->lsb_resol = DIV_ROUND_CLOSEST(data->vref_mv * 1000, 256);
		data->read_channel = i2c_smbus_read_byte_data;
	}

	data->cmd_byte = data->ext_vref ? ADS7828_CMD_PD1 : ADS7828_CMD_PD3;
	if (!data->diff_input)
		data->cmd_byte |= ADS7828_CMD_SD_SE;

	data->client = client;
	mutex_init(&data->update_lock);

	hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name,
							   data,
							   ads7828_groups);
	return PTR_ERR_OR_ZERO(hwmon_dev);
}

static const struct i2c_device_id ads7828_device_ids[] = {
	{ "ads7828", ads7828 },
	{ "ads7830", ads7830 },
	{ }
};
MODULE_DEVICE_TABLE(i2c, ads7828_device_ids);

static struct i2c_driver ads7828_driver = {
	.driver = {
		.name = "ads7828",
	},

	.id_table = ads7828_device_ids,
	.probe = ads7828_probe,
};

module_i2c_driver(ads7828_driver);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Steve Hardy <shardy@redhat.com>");
MODULE_DESCRIPTION("Driver for TI ADS7828 A/D converter and compatibles");
Commit	Line	Data
5812f928	1	/*
0962e0f1	2	* ads7828.c - driver for TI ADS7828 8-channel A/D converter and compatibles
d13d6232 GR	3	* (C) 2007 EADS Astrium
	4	*
	5	* This driver is based on the lm75 and other lm_sensors/hwmon drivers
	6	*
	7	* Written by Steve Hardy <shardy@redhat.com>
	8	*
0962e0f1 GR	9	* ADS7830 support, by Guillaume Roguez <guillaume.roguez@savoirfairelinux.com>
0962e0f1 GR	10	*
46d78462	11	* For further information, see the Documentation/hwmon/ads7828 file.
d13d6232 GR	12	*
	13	* This program is free software; you can redistribute it and/or modify
	14	* it under the terms of the GNU General Public License as published by
	15	* the Free Software Foundation; either version 2 of the License, or
	16	* (at your option) any later version.
	17	*
	18	* This program is distributed in the hope that it will be useful,
	19	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	20	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	21	* GNU General Public License for more details.
	22	*
	23	* You should have received a copy of the GNU General Public License
	24	* along with this program; if not, write to the Free Software
	25	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
	26	*/
5812f928	27
46d78462	28	#include <linux/err.h>
5812f928 SH	29	#include <linux/hwmon.h>
5812f928 SH	30	#include <linux/hwmon-sysfs.h>
46d78462 VD	31	#include <linux/i2c.h>
	32	#include <linux/init.h>
	33	#include <linux/jiffies.h>
	34	#include <linux/module.h>
5812f928	35	#include <linux/mutex.h>
46d78462 VD	36	#include <linux/platform_data/ads7828.h>
46d78462 VD	37	#include <linux/slab.h>
5812f928 SH	38
5812f928 SH	39	/* The ADS7828 registers */
46d78462 VD	40	#define ADS7828_NCH 8 /* 8 channels supported */
	41	#define ADS7828_CMD_SD_SE 0x80 /* Single ended inputs */
	42	#define ADS7828_CMD_PD1 0x04 /* Internal vref OFF && A/D ON */
	43	#define ADS7828_CMD_PD3 0x0C /* Internal vref ON && A/D ON */
	44	#define ADS7828_INT_VREF_MV 2500 /* Internal vref is 2.5V, 2500mV */
	45	#define ADS7828_EXT_VREF_MV_MIN 50 /* External vref min value 0.05V */
	46	#define ADS7828_EXT_VREF_MV_MAX 5250 /* External vref max value 5.25V */
	47
0962e0f1 GR	48	/* List of supported devices */
	49	enum ads7828_chips { ads7828, ads7830 };
	50
46d78462	51	/* Client specific data */
5812f928	52	struct ads7828_data {
f82b2c34	53	struct i2c_client *client;
46d78462 VD	54	struct mutex update_lock; /* Mutex protecting updates */
	55	unsigned long last_updated; /* Last updated time (in jiffies) */
	56	u16 adc_input[ADS7828_NCH]; /* ADS7828_NCH samples */
	57	bool valid; /* Validity flag */
	58	bool diff_input; /* Differential input */
	59	bool ext_vref; /* External voltage reference */
	60	unsigned int vref_mv; /* voltage reference value */
	61	u8 cmd_byte; /* Command byte without channel bits */
	62	unsigned int lsb_resol; /* Resolution of the ADC sample LSB */
0962e0f1	63	s32 (read_channel)(const struct i2c_client client, u8 command);
5812f928 SH	64	};
5812f928 SH	65
46d78462 VD	66	/* Command byte C2,C1,C0 - see datasheet */
46d78462 VD	67	static inline u8 ads7828_cmd_byte(u8 cmd, int ch)
5812f928	68	{
46d78462	69	return cmd \| (((ch >> 1) \| (ch & 0x01) << 2) << 4);
5812f928 SH	70	}
	71
	72	/* Update data for the device (all 8 channels) */
	73	static struct ads7828_data ads7828_update_device(struct device dev)
	74	{
f82b2c34 AL	75	struct ads7828_data *data = dev_get_drvdata(dev);
f82b2c34 AL	76	struct i2c_client *client = data->client;
5812f928 SH	77
	78	mutex_lock(&data->update_lock);
	79
	80	if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
	81	\|\| !data->valid) {
	82	unsigned int ch;
	83	dev_dbg(&client->dev, "Starting ads7828 update\n");
	84
	85	for (ch = 0; ch < ADS7828_NCH; ch++) {
46d78462	86	u8 cmd = ads7828_cmd_byte(data->cmd_byte, ch);
0962e0f1	87	data->adc_input[ch] = data->read_channel(client, cmd);
5812f928 SH	88	}
5812f928 SH	89	data->last_updated = jiffies;
46d78462	90	data->valid = true;
5812f928 SH	91	}
	92
	93	mutex_unlock(&data->update_lock);
	94
	95	return data;
	96	}
	97
	98	/* sysfs callback function */
46d78462 VD	99	static ssize_t ads7828_show_in(struct device dev, struct device_attribute da,
46d78462 VD	100	char *buf)
5812f928 SH	101	{
	102	struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
	103	struct ads7828_data *data = ads7828_update_device(dev);
46d78462 VD	104	unsigned int value = DIV_ROUND_CLOSEST(data->adc_input[attr->index] *
46d78462 VD	105	data->lsb_resol, 1000);
5812f928	106
46d78462 VD	107	return sprintf(buf, "%d\n", value);
46d78462 VD	108	}
5812f928	109
46d78462 VD	110	static SENSOR_DEVICE_ATTR(in0_input, S_IRUGO, ads7828_show_in, NULL, 0);
	111	static SENSOR_DEVICE_ATTR(in1_input, S_IRUGO, ads7828_show_in, NULL, 1);
	112	static SENSOR_DEVICE_ATTR(in2_input, S_IRUGO, ads7828_show_in, NULL, 2);
	113	static SENSOR_DEVICE_ATTR(in3_input, S_IRUGO, ads7828_show_in, NULL, 3);
	114	static SENSOR_DEVICE_ATTR(in4_input, S_IRUGO, ads7828_show_in, NULL, 4);
	115	static SENSOR_DEVICE_ATTR(in5_input, S_IRUGO, ads7828_show_in, NULL, 5);
	116	static SENSOR_DEVICE_ATTR(in6_input, S_IRUGO, ads7828_show_in, NULL, 6);
	117	static SENSOR_DEVICE_ATTR(in7_input, S_IRUGO, ads7828_show_in, NULL, 7);
5812f928	118
f82b2c34	119	static struct attribute *ads7828_attrs[] = {
5812f928 SH	120	&sensor_dev_attr_in0_input.dev_attr.attr,
	121	&sensor_dev_attr_in1_input.dev_attr.attr,
	122	&sensor_dev_attr_in2_input.dev_attr.attr,
	123	&sensor_dev_attr_in3_input.dev_attr.attr,
	124	&sensor_dev_attr_in4_input.dev_attr.attr,
	125	&sensor_dev_attr_in5_input.dev_attr.attr,
	126	&sensor_dev_attr_in6_input.dev_attr.attr,
	127	&sensor_dev_attr_in7_input.dev_attr.attr,
	128	NULL
	129	};
	130
f82b2c34	131	ATTRIBUTE_GROUPS(ads7828);
5812f928	132
7347cb38 JD	133	static int ads7828_probe(struct i2c_client *client,
	134	const struct i2c_device_id *id)
	135	{
f82b2c34 AL	136	struct device *dev = &client->dev;
f82b2c34 AL	137	struct ads7828_platform_data *pdata = dev_get_platdata(dev);
7347cb38	138	struct ads7828_data *data;
f82b2c34	139	struct device *hwmon_dev;
5812f928	140
f82b2c34	141	data = devm_kzalloc(dev, sizeof(struct ads7828_data), GFP_KERNEL);
34e3f7f5 GR	142	if (!data)
34e3f7f5 GR	143	return -ENOMEM;
5812f928	144
46d78462 VD	145	if (pdata) {
	146	data->diff_input = pdata->diff_input;
	147	data->ext_vref = pdata->ext_vref;
	148	if (data->ext_vref)
	149	data->vref_mv = pdata->vref_mv;
	150	}
	151
	152	/* Bound Vref with min/max values if it was provided */
	153	if (data->vref_mv)
2a844c14 GR	154	data->vref_mv = clamp_val(data->vref_mv,
	155	ADS7828_EXT_VREF_MV_MIN,
	156	ADS7828_EXT_VREF_MV_MAX);
46d78462 VD	157	else
	158	data->vref_mv = ADS7828_INT_VREF_MV;
	159
0962e0f1 GR	160	/* ADS7828 uses 12-bit samples, while ADS7830 is 8-bit */
	161	if (id->driver_data == ads7828) {
	162	data->lsb_resol = DIV_ROUND_CLOSEST(data->vref_mv * 1000, 4096);
	163	data->read_channel = i2c_smbus_read_word_swapped;
	164	} else {
	165	data->lsb_resol = DIV_ROUND_CLOSEST(data->vref_mv * 1000, 256);
	166	data->read_channel = i2c_smbus_read_byte_data;
	167	}
46d78462 VD	168
	169	data->cmd_byte = data->ext_vref ? ADS7828_CMD_PD1 : ADS7828_CMD_PD3;
	170	if (!data->diff_input)
	171	data->cmd_byte \|= ADS7828_CMD_SD_SE;
	172
f82b2c34	173	data->client = client;
5812f928 SH	174	mutex_init(&data->update_lock);
5812f928 SH	175
f82b2c34 AL	176	hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name,
	177	data,
	178	ads7828_groups);
	179	return PTR_ERR_OR_ZERO(hwmon_dev);
5812f928 SH	180	}
5812f928 SH	181
46d78462	182	static const struct i2c_device_id ads7828_device_ids[] = {
0962e0f1 GR	183	{ "ads7828", ads7828 },
0962e0f1 GR	184	{ "ads7830", ads7830 },
46d78462 VD	185	{ }
	186	};
	187	MODULE_DEVICE_TABLE(i2c, ads7828_device_ids);
5812f928	188
46d78462 VD	189	static struct i2c_driver ads7828_driver = {
	190	.driver = {
	191	.name = "ads7828",
	192	},
5812f928	193
46d78462 VD	194	.id_table = ads7828_device_ids,
46d78462 VD	195	.probe = ads7828_probe,
46d78462	196	};
5812f928	197
46d78462	198	module_i2c_driver(ads7828_driver);
5812f928	199
5812f928	200	MODULE_LICENSE("GPL");
46d78462	201	MODULE_AUTHOR("Steve Hardy <shardy@redhat.com>");
0962e0f1	202	MODULE_DESCRIPTION("Driver for TI ADS7828 A/D converter and compatibles");