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

/* Sensirion SHT21 humidity and temperature sensor driver
 *
 * Copyright (C) 2010 Urs Fleisch <urs.fleisch@sensirion.com>
 *
 * 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., 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA
 *
 * Data sheet available at http://www.sensirion.com/file/datasheet_sht21
 */

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

/* I2C command bytes */
#define SHT21_TRIG_T_MEASUREMENT_HM  0xe3
#define SHT21_TRIG_RH_MEASUREMENT_HM 0xe5
#define SHT21_READ_SNB_CMD1 0xFA
#define SHT21_READ_SNB_CMD2 0x0F
#define SHT21_READ_SNAC_CMD1 0xFC
#define SHT21_READ_SNAC_CMD2 0xC9

/**
 * struct sht21 - SHT21 device specific data
 * @client: I2C client device
 * @lock: mutex to protect measurement values
 * @last_update: time of last update (jiffies)
 * @temperature: cached temperature measurement value
 * @humidity: cached humidity measurement value
 * @valid: only 0 before first measurement is taken
 * @eic: cached electronic identification code text
 */
struct sht21 {
	struct i2c_client *client;
	struct mutex lock;
	unsigned long last_update;
	int temperature;
	int humidity;
	char valid;
	char eic[18];
};

/**
 * sht21_temp_ticks_to_millicelsius() - convert raw temperature ticks to
 * milli celsius
 * @ticks: temperature ticks value received from sensor
 */
static inline int sht21_temp_ticks_to_millicelsius(int ticks)
{
	ticks &= ~0x0003; /* clear status bits */
	/*
	 * Formula T = -46.85 + 175.72 * ST / 2^16 from data sheet 6.2,
	 * optimized for integer fixed point (3 digits) arithmetic
	 */
	return ((21965 * ticks) >> 13) - 46850;
}

/**
 * sht21_rh_ticks_to_per_cent_mille() - convert raw humidity ticks to
 * one-thousandths of a percent relative humidity
 * @ticks: humidity ticks value received from sensor
 */
static inline int sht21_rh_ticks_to_per_cent_mille(int ticks)
{
	ticks &= ~0x0003; /* clear status bits */
	/*
	 * Formula RH = -6 + 125 * SRH / 2^16 from data sheet 6.1,
	 * optimized for integer fixed point (3 digits) arithmetic
	 */
	return ((15625 * ticks) >> 13) - 6000;
}

/**
 * sht21_update_measurements() - get updated measurements from device
 * @dev: device
 *
 * Returns 0 on success, else negative errno.
 */
static int sht21_update_measurements(struct device *dev)
{
	int ret = 0;
	struct sht21 *sht21 = dev_get_drvdata(dev);
	struct i2c_client *client = sht21->client;

	mutex_lock(&sht21->lock);
	/*
	 * Data sheet 2.4:
	 * SHT2x should not be active for more than 10% of the time - e.g.
	 * maximum two measurements per second at 12bit accuracy shall be made.
	 */
	if (time_after(jiffies, sht21->last_update + HZ / 2) || !sht21->valid) {
		ret = i2c_smbus_read_word_swapped(client,
						  SHT21_TRIG_T_MEASUREMENT_HM);
		if (ret < 0)
			goto out;
		sht21->temperature = sht21_temp_ticks_to_millicelsius(ret);
		ret = i2c_smbus_read_word_swapped(client,
						  SHT21_TRIG_RH_MEASUREMENT_HM);
		if (ret < 0)
			goto out;
		sht21->humidity = sht21_rh_ticks_to_per_cent_mille(ret);
		sht21->last_update = jiffies;
		sht21->valid = 1;
	}
out:
	mutex_unlock(&sht21->lock);

	return ret >= 0 ? 0 : ret;
}

/**
 * sht21_show_temperature() - show temperature measurement value in sysfs
 * @dev: device
 * @attr: device attribute
 * @buf: sysfs buffer (PAGE_SIZE) where measurement values are written to
 *
 * Will be called on read access to temp1_input sysfs attribute.
 * Returns number of bytes written into buffer, negative errno on error.
 */
static ssize_t sht21_show_temperature(struct device *dev,
	struct device_attribute *attr,
	char *buf)
{
	struct sht21 *sht21 = dev_get_drvdata(dev);
	int ret;

	ret = sht21_update_measurements(dev);
	if (ret < 0)
		return ret;
	return sprintf(buf, "%d\n", sht21->temperature);
}

/**
 * sht21_show_humidity() - show humidity measurement value in sysfs
 * @dev: device
 * @attr: device attribute
 * @buf: sysfs buffer (PAGE_SIZE) where measurement values are written to
 *
 * Will be called on read access to humidity1_input sysfs attribute.
 * Returns number of bytes written into buffer, negative errno on error.
 */
static ssize_t sht21_show_humidity(struct device *dev,
	struct device_attribute *attr,
	char *buf)
{
	struct sht21 *sht21 = dev_get_drvdata(dev);
	int ret;

	ret = sht21_update_measurements(dev);
	if (ret < 0)
		return ret;
	return sprintf(buf, "%d\n", sht21->humidity);
}

static ssize_t eic_read(struct sht21 *sht21)
{
	struct i2c_client *client = sht21->client;
	u8 tx[2];
	u8 rx[8];
	u8 eic[8];
	struct i2c_msg msgs[2] = {
		{
			.addr = client->addr,
			.flags = 0,
			.len = 2,
			.buf = tx,
		},
		{
			.addr = client->addr,
			.flags = I2C_M_RD,
			.len = 8,
			.buf = rx,
		},
	};
	int ret;

	tx[0] = SHT21_READ_SNB_CMD1;
	tx[1] = SHT21_READ_SNB_CMD2;
	ret = i2c_transfer(client->adapter, msgs, 2);
	if (ret < 0)
		goto out;
	eic[2] = rx[0];
	eic[3] = rx[2];
	eic[4] = rx[4];
	eic[5] = rx[6];

	tx[0] = SHT21_READ_SNAC_CMD1;
	tx[1] = SHT21_READ_SNAC_CMD2;
	msgs[1].len = 6;
	ret = i2c_transfer(client->adapter, msgs, 2);
	if (ret < 0)
		goto out;
	eic[0] = rx[3];
	eic[1] = rx[4];
	eic[6] = rx[0];
	eic[7] = rx[1];

	ret = snprintf(sht21->eic, sizeof(sht21->eic),
		       "%02x%02x%02x%02x%02x%02x%02x%02x\n",
		       eic[0], eic[1], eic[2], eic[3],
		       eic[4], eic[5], eic[6], eic[7]);
out:
	if (ret < 0)
		sht21->eic[0] = 0;

	return ret;
}

/**
 * eic_show() - show Electronic Identification Code in sysfs
 * @dev: device
 * @attr: device attribute
 * @buf: sysfs buffer (PAGE_SIZE) where EIC is written
 *
 * Will be called on read access to eic sysfs attribute.
 * Returns number of bytes written into buffer, negative errno on error.
 */
static ssize_t eic_show(struct device *dev,
	struct device_attribute *attr,
	char *buf)
{
	struct sht21 *sht21 = dev_get_drvdata(dev);
	int ret;

	ret = sizeof(sht21->eic) - 1;
	mutex_lock(&sht21->lock);
	if (!sht21->eic[0])
		ret = eic_read(sht21);
	if (ret > 0)
		memcpy(buf, sht21->eic, ret);
	mutex_unlock(&sht21->lock);
	return ret;
}

/* sysfs attributes */
static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, sht21_show_temperature,
	NULL, 0);
static SENSOR_DEVICE_ATTR(humidity1_input, S_IRUGO, sht21_show_humidity,
	NULL, 0);
static DEVICE_ATTR_RO(eic);

static struct attribute *sht21_attrs[] = {
	&sensor_dev_attr_temp1_input.dev_attr.attr,
	&sensor_dev_attr_humidity1_input.dev_attr.attr,
	&dev_attr_eic.attr,
	NULL
};

ATTRIBUTE_GROUPS(sht21);

static int sht21_probe(struct i2c_client *client,
	const struct i2c_device_id *id)
{
	struct device *dev = &client->dev;
	struct device *hwmon_dev;
	struct sht21 *sht21;

	if (!i2c_check_functionality(client->adapter,
				     I2C_FUNC_SMBUS_WORD_DATA)) {
		dev_err(&client->dev,
			"adapter does not support SMBus word transactions\n");
		return -ENODEV;
	}

	sht21 = devm_kzalloc(dev, sizeof(*sht21), GFP_KERNEL);
	if (!sht21)
		return -ENOMEM;

	sht21->client = client;

	mutex_init(&sht21->lock);

	hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name,
							   sht21, sht21_groups);
	return PTR_ERR_OR_ZERO(hwmon_dev);
}

/* Device ID table */
static const struct i2c_device_id sht21_id[] = {
	{ "sht21", 0 },
	{ }
};
MODULE_DEVICE_TABLE(i2c, sht21_id);

static struct i2c_driver sht21_driver = {
	.driver.name = "sht21",
	.probe       = sht21_probe,
	.id_table    = sht21_id,
};

module_i2c_driver(sht21_driver);

MODULE_AUTHOR("Urs Fleisch <urs.fleisch@sensirion.com>");
MODULE_DESCRIPTION("Sensirion SHT21 humidity and temperature sensor driver");
MODULE_LICENSE("GPL");
Commit	Line	Data
430400b8 UF	1	/* Sensirion SHT21 humidity and temperature sensor driver
	2	*
	3	* Copyright (C) 2010 Urs Fleisch <urs.fleisch@sensirion.com>
	4	*
	5	* This program is free software; you can redistribute it and/or modify
	6	* it under the terms of the GNU General Public License as published by
	7	* the Free Software Foundation; either version 2 of the License, or
	8	* (at your option) any later version.
	9	*
	10	* This program is distributed in the hope that it will be useful,
	11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	* GNU General Public License for more details.
	14	*
	15	* You should have received a copy of the GNU General Public License
	16	* along with this program; if not, write to the Free Software
	17	* Foundation, Inc., 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA
	18	*
8e1d6fe9	19	* Data sheet available at http://www.sensirion.com/file/datasheet_sht21
430400b8 UF	20	*/
	21
	22	#include <linux/module.h>
	23	#include <linux/init.h>
	24	#include <linux/slab.h>
	25	#include <linux/i2c.h>
	26	#include <linux/hwmon.h>
	27	#include <linux/hwmon-sysfs.h>
	28	#include <linux/err.h>
	29	#include <linux/mutex.h>
	30	#include <linux/device.h>
dcd8f392	31	#include <linux/jiffies.h>
430400b8 UF	32
	33	/* I2C command bytes */
	34	#define SHT21_TRIG_T_MEASUREMENT_HM 0xe3
	35	#define SHT21_TRIG_RH_MEASUREMENT_HM 0xe5
53e678d7 PB	36	#define SHT21_READ_SNB_CMD1 0xFA
	37	#define SHT21_READ_SNB_CMD2 0x0F
	38	#define SHT21_READ_SNAC_CMD1 0xFC
	39	#define SHT21_READ_SNAC_CMD2 0xC9
430400b8 UF	40
	41	/**
	42	* struct sht21 - SHT21 device specific data
679f50b8	43	* @client: I2C client device
430400b8	44	* @lock: mutex to protect measurement values
430400b8 UF	45	* @last_update: time of last update (jiffies)
	46	* @temperature: cached temperature measurement value
	47	* @humidity: cached humidity measurement value
53e678d7 PB	48	* @valid: only 0 before first measurement is taken
53e678d7 PB	49	* @eic: cached electronic identification code text
430400b8 UF	50	*/
430400b8 UF	51	struct sht21 {
b8d56898	52	struct i2c_client *client;
430400b8	53	struct mutex lock;
430400b8 UF	54	unsigned long last_update;
	55	int temperature;
	56	int humidity;
53e678d7 PB	57	char valid;
53e678d7 PB	58	char eic[18];
430400b8 UF	59	};
	60
	61	/**
	62	* sht21_temp_ticks_to_millicelsius() - convert raw temperature ticks to
	63	* milli celsius
	64	* @ticks: temperature ticks value received from sensor
	65	*/
	66	static inline int sht21_temp_ticks_to_millicelsius(int ticks)
	67	{
	68	ticks &= ~0x0003; /* clear status bits */
	69	/*
	70	* Formula T = -46.85 + 175.72 * ST / 2^16 from data sheet 6.2,
	71	* optimized for integer fixed point (3 digits) arithmetic
	72	*/
	73	return ((21965 * ticks) >> 13) - 46850;
	74	}
	75
	76	/**
	77	* sht21_rh_ticks_to_per_cent_mille() - convert raw humidity ticks to
	78	* one-thousandths of a percent relative humidity
	79	* @ticks: humidity ticks value received from sensor
	80	*/
	81	static inline int sht21_rh_ticks_to_per_cent_mille(int ticks)
	82	{
	83	ticks &= ~0x0003; /* clear status bits */
	84	/*
	85	* Formula RH = -6 + 125 * SRH / 2^16 from data sheet 6.1,
	86	* optimized for integer fixed point (3 digits) arithmetic
	87	*/
	88	return ((15625 * ticks) >> 13) - 6000;
	89	}
	90
430400b8 UF	91	/**
430400b8 UF	92	* sht21_update_measurements() - get updated measurements from device
b8d56898	93	* @dev: device
430400b8 UF	94	*
	95	* Returns 0 on success, else negative errno.
	96	*/
b8d56898	97	static int sht21_update_measurements(struct device *dev)
430400b8 UF	98	{
430400b8 UF	99	int ret = 0;
b8d56898 AL	100	struct sht21 *sht21 = dev_get_drvdata(dev);
b8d56898 AL	101	struct i2c_client *client = sht21->client;
430400b8 UF	102
	103	mutex_lock(&sht21->lock);
	104	/*
	105	* Data sheet 2.4:
	106	* SHT2x should not be active for more than 10% of the time - e.g.
	107	* maximum two measurements per second at 12bit accuracy shall be made.
	108	*/
	109	if (time_after(jiffies, sht21->last_update + HZ / 2) \|\| !sht21->valid) {
90f4102c JD	110	ret = i2c_smbus_read_word_swapped(client,
90f4102c JD	111	SHT21_TRIG_T_MEASUREMENT_HM);
430400b8 UF	112	if (ret < 0)
	113	goto out;
	114	sht21->temperature = sht21_temp_ticks_to_millicelsius(ret);
90f4102c JD	115	ret = i2c_smbus_read_word_swapped(client,
90f4102c JD	116	SHT21_TRIG_RH_MEASUREMENT_HM);
430400b8 UF	117	if (ret < 0)
	118	goto out;
	119	sht21->humidity = sht21_rh_ticks_to_per_cent_mille(ret);
	120	sht21->last_update = jiffies;
	121	sht21->valid = 1;
	122	}
	123	out:
	124	mutex_unlock(&sht21->lock);
	125
	126	return ret >= 0 ? 0 : ret;
	127	}
	128
	129	/**
	130	* sht21_show_temperature() - show temperature measurement value in sysfs
	131	* @dev: device
	132	* @attr: device attribute
	133	* @buf: sysfs buffer (PAGE_SIZE) where measurement values are written to
	134	*
	135	* Will be called on read access to temp1_input sysfs attribute.
	136	* Returns number of bytes written into buffer, negative errno on error.
	137	*/
	138	static ssize_t sht21_show_temperature(struct device *dev,
	139	struct device_attribute *attr,
	140	char *buf)
	141	{
b8d56898 AL	142	struct sht21 *sht21 = dev_get_drvdata(dev);
	143	int ret;
	144
	145	ret = sht21_update_measurements(dev);
430400b8 UF	146	if (ret < 0)
	147	return ret;
	148	return sprintf(buf, "%d\n", sht21->temperature);
	149	}
	150
	151	/**
	152	* sht21_show_humidity() - show humidity measurement value in sysfs
	153	* @dev: device
	154	* @attr: device attribute
	155	* @buf: sysfs buffer (PAGE_SIZE) where measurement values are written to
	156	*
	157	* Will be called on read access to humidity1_input sysfs attribute.
	158	* Returns number of bytes written into buffer, negative errno on error.
	159	*/
	160	static ssize_t sht21_show_humidity(struct device *dev,
	161	struct device_attribute *attr,
	162	char *buf)
	163	{
b8d56898 AL	164	struct sht21 *sht21 = dev_get_drvdata(dev);
	165	int ret;
	166
	167	ret = sht21_update_measurements(dev);
430400b8 UF	168	if (ret < 0)
	169	return ret;
	170	return sprintf(buf, "%d\n", sht21->humidity);
	171	}
	172
53e678d7 PB	173	static ssize_t eic_read(struct sht21 *sht21)
	174	{
	175	struct i2c_client *client = sht21->client;
	176	u8 tx[2];
	177	u8 rx[8];
	178	u8 eic[8];
	179	struct i2c_msg msgs[2] = {
	180	{
	181	.addr = client->addr,
	182	.flags = 0,
	183	.len = 2,
	184	.buf = tx,
	185	},
	186	{
	187	.addr = client->addr,
	188	.flags = I2C_M_RD,
	189	.len = 8,
	190	.buf = rx,
	191	},
	192	};
	193	int ret;
	194
	195	tx[0] = SHT21_READ_SNB_CMD1;
	196	tx[1] = SHT21_READ_SNB_CMD2;
	197	ret = i2c_transfer(client->adapter, msgs, 2);
	198	if (ret < 0)
	199	goto out;
	200	eic[2] = rx[0];
	201	eic[3] = rx[2];
	202	eic[4] = rx[4];
	203	eic[5] = rx[6];
	204
	205	tx[0] = SHT21_READ_SNAC_CMD1;
	206	tx[1] = SHT21_READ_SNAC_CMD2;
	207	msgs[1].len = 6;
	208	ret = i2c_transfer(client->adapter, msgs, 2);
	209	if (ret < 0)
	210	goto out;
	211	eic[0] = rx[3];
	212	eic[1] = rx[4];
	213	eic[6] = rx[0];
	214	eic[7] = rx[1];
	215
	216	ret = snprintf(sht21->eic, sizeof(sht21->eic),
	217	"%02x%02x%02x%02x%02x%02x%02x%02x\n",
	218	eic[0], eic[1], eic[2], eic[3],
	219	eic[4], eic[5], eic[6], eic[7]);
	220	out:
	221	if (ret < 0)
	222	sht21->eic[0] = 0;
	223
	224	return ret;
	225	}
	226
	227	/**
	228	* eic_show() - show Electronic Identification Code in sysfs
	229	* @dev: device
	230	* @attr: device attribute
	231	* @buf: sysfs buffer (PAGE_SIZE) where EIC is written
	232	*
	233	* Will be called on read access to eic sysfs attribute.
	234	* Returns number of bytes written into buffer, negative errno on error.
	235	*/
	236	static ssize_t eic_show(struct device *dev,
237	struct device_attribute *attr,
238	char *buf)
239	{
240	struct sht21 *sht21 = dev_get_drvdata(dev);
241	int ret;
242
243	ret = sizeof(sht21->eic) - 1;
244	mutex_lock(&sht21->lock);
245	if (!sht21->eic[0])
246	ret = eic_read(sht21);
247	if (ret > 0)
248	memcpy(buf, sht21->eic, ret);
249	mutex_unlock(&sht21->lock);
250	return ret;
251	}
252
430400b8 UF	253	/* sysfs attributes */
	254	static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, sht21_show_temperature,
	255	NULL, 0);
	256	static SENSOR_DEVICE_ATTR(humidity1_input, S_IRUGO, sht21_show_humidity,
	257	NULL, 0);
53e678d7	258	static DEVICE_ATTR_RO(eic);
430400b8	259
b8d56898	260	static struct attribute *sht21_attrs[] = {
430400b8 UF	261	&sensor_dev_attr_temp1_input.dev_attr.attr,
430400b8 UF	262	&sensor_dev_attr_humidity1_input.dev_attr.attr,
53e678d7	263	&dev_attr_eic.attr,
430400b8 UF	264	NULL
	265	};
	266
b8d56898	267	ATTRIBUTE_GROUPS(sht21);
430400b8	268
6c931ae1	269	static int sht21_probe(struct i2c_client *client,
430400b8 UF	270	const struct i2c_device_id *id)
430400b8 UF	271	{
b8d56898 AL	272	struct device *dev = &client->dev;
b8d56898 AL	273	struct device *hwmon_dev;
430400b8	274	struct sht21 *sht21;
430400b8 UF	275
	276	if (!i2c_check_functionality(client->adapter,
	277	I2C_FUNC_SMBUS_WORD_DATA)) {
	278	dev_err(&client->dev,
	279	"adapter does not support SMBus word transactions\n");
	280	return -ENODEV;
	281	}
	282
b8d56898	283	sht21 = devm_kzalloc(dev, sizeof(*sht21), GFP_KERNEL);
a844af19	284	if (!sht21)
430400b8	285	return -ENOMEM;
a844af19	286
b8d56898	287	sht21->client = client;
430400b8 UF	288
	289	mutex_init(&sht21->lock);
	290
b8d56898 AL	291	hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name,
	292	sht21, sht21_groups);
	293	return PTR_ERR_OR_ZERO(hwmon_dev);
430400b8 UF	294	}
	295
	296	/* Device ID table */
	297	static const struct i2c_device_id sht21_id[] = {
	298	{ "sht21", 0 },
	299	{ }
	300	};
	301	MODULE_DEVICE_TABLE(i2c, sht21_id);
	302
	303	static struct i2c_driver sht21_driver = {
	304	.driver.name = "sht21",
	305	.probe = sht21_probe,
430400b8 UF	306	.id_table = sht21_id,
	307	};
	308
f0967eea	309	module_i2c_driver(sht21_driver);
430400b8 UF	310
	311	MODULE_AUTHOR("Urs Fleisch <urs.fleisch@sensirion.com>");
	312	MODULE_DESCRIPTION("Sensirion SHT21 humidity and temperature sensor driver");
	313	MODULE_LICENSE("GPL");