[linux-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_temperature_show(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_humidity_show(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_RO(temp1_input, sht21_temperature, 0);
static SENSOR_DEVICE_ATTR_RO(humidity1_input, sht21_humidity, 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	*/
5512eb06 GR	138	static ssize_t sht21_temperature_show(struct device *dev,
	139	struct device_attribute *attr,
	140	char *buf)
430400b8	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	*/
5512eb06 GR	160	static ssize_t sht21_humidity_show(struct device *dev,
5512eb06 GR	161	struct device_attribute attr, char buf)
430400b8	162	{
b8d56898 AL	163	struct sht21 *sht21 = dev_get_drvdata(dev);
	164	int ret;
	165
	166	ret = sht21_update_measurements(dev);
430400b8 UF	167	if (ret < 0)
	168	return ret;
	169	return sprintf(buf, "%d\n", sht21->humidity);
	170	}
	171
53e678d7 PB	172	static ssize_t eic_read(struct sht21 *sht21)
	173	{
	174	struct i2c_client *client = sht21->client;
	175	u8 tx[2];
	176	u8 rx[8];
	177	u8 eic[8];
	178	struct i2c_msg msgs[2] = {
	179	{
	180	.addr = client->addr,
	181	.flags = 0,
	182	.len = 2,
	183	.buf = tx,
	184	},
	185	{
	186	.addr = client->addr,
	187	.flags = I2C_M_RD,
	188	.len = 8,
	189	.buf = rx,
	190	},
	191	};
	192	int ret;
	193
	194	tx[0] = SHT21_READ_SNB_CMD1;
	195	tx[1] = SHT21_READ_SNB_CMD2;
	196	ret = i2c_transfer(client->adapter, msgs, 2);
	197	if (ret < 0)
	198	goto out;
	199	eic[2] = rx[0];
	200	eic[3] = rx[2];
	201	eic[4] = rx[4];
	202	eic[5] = rx[6];
	203
	204	tx[0] = SHT21_READ_SNAC_CMD1;
	205	tx[1] = SHT21_READ_SNAC_CMD2;
	206	msgs[1].len = 6;
	207	ret = i2c_transfer(client->adapter, msgs, 2);
	208	if (ret < 0)
	209	goto out;
	210	eic[0] = rx[3];
	211	eic[1] = rx[4];
	212	eic[6] = rx[0];
	213	eic[7] = rx[1];
	214
	215	ret = snprintf(sht21->eic, sizeof(sht21->eic),
	216	"%02x%02x%02x%02x%02x%02x%02x%02x\n",
	217	eic[0], eic[1], eic[2], eic[3],
	218	eic[4], eic[5], eic[6], eic[7]);
	219	out:
	220	if (ret < 0)
	221	sht21->eic[0] = 0;
	222
	223	return ret;
	224	}
	225
	226	/**
	227	* eic_show() - show Electronic Identification Code in sysfs
	228	* @dev: device
	229	* @attr: device attribute
	230	* @buf: sysfs buffer (PAGE_SIZE) where EIC is written
	231	*
	232	* Will be called on read access to eic sysfs attribute.
	233	* Returns number of bytes written into buffer, negative errno on error.
	234	*/
	235	static ssize_t eic_show(struct device *dev,
236	struct device_attribute *attr,
237	char *buf)
238	{
239	struct sht21 *sht21 = dev_get_drvdata(dev);
240	int ret;
241
242	ret = sizeof(sht21->eic) - 1;
243	mutex_lock(&sht21->lock);
244	if (!sht21->eic[0])
245	ret = eic_read(sht21);
246	if (ret > 0)
247	memcpy(buf, sht21->eic, ret);
248	mutex_unlock(&sht21->lock);
249	return ret;
250	}
251
430400b8	252	/* sysfs attributes */
5512eb06 GR	253	static SENSOR_DEVICE_ATTR_RO(temp1_input, sht21_temperature, 0);
5512eb06 GR	254	static SENSOR_DEVICE_ATTR_RO(humidity1_input, sht21_humidity, 0);
53e678d7	255	static DEVICE_ATTR_RO(eic);
430400b8	256
b8d56898	257	static struct attribute *sht21_attrs[] = {
430400b8 UF	258	&sensor_dev_attr_temp1_input.dev_attr.attr,
430400b8 UF	259	&sensor_dev_attr_humidity1_input.dev_attr.attr,
53e678d7	260	&dev_attr_eic.attr,
430400b8 UF	261	NULL
	262	};
	263
b8d56898	264	ATTRIBUTE_GROUPS(sht21);
430400b8	265
6c931ae1	266	static int sht21_probe(struct i2c_client *client,
430400b8 UF	267	const struct i2c_device_id *id)
430400b8 UF	268	{
b8d56898 AL	269	struct device *dev = &client->dev;
b8d56898 AL	270	struct device *hwmon_dev;
430400b8	271	struct sht21 *sht21;
430400b8 UF	272
	273	if (!i2c_check_functionality(client->adapter,
	274	I2C_FUNC_SMBUS_WORD_DATA)) {
	275	dev_err(&client->dev,
	276	"adapter does not support SMBus word transactions\n");
	277	return -ENODEV;
	278	}
	279
b8d56898	280	sht21 = devm_kzalloc(dev, sizeof(*sht21), GFP_KERNEL);
a844af19	281	if (!sht21)
430400b8	282	return -ENOMEM;
a844af19	283
b8d56898	284	sht21->client = client;
430400b8 UF	285
	286	mutex_init(&sht21->lock);
	287
b8d56898 AL	288	hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name,
	289	sht21, sht21_groups);
	290	return PTR_ERR_OR_ZERO(hwmon_dev);
430400b8 UF	291	}
	292
	293	/* Device ID table */
	294	static const struct i2c_device_id sht21_id[] = {
	295	{ "sht21", 0 },
	296	{ }
	297	};
	298	MODULE_DEVICE_TABLE(i2c, sht21_id);
	299
	300	static struct i2c_driver sht21_driver = {
	301	.driver.name = "sht21",
	302	.probe = sht21_probe,
430400b8 UF	303	.id_table = sht21_id,
	304	};
	305
f0967eea	306	module_i2c_driver(sht21_driver);
430400b8 UF	307
	308	MODULE_AUTHOR("Urs Fleisch <urs.fleisch@sensirion.com>");
	309	MODULE_DESCRIPTION("Sensirion SHT21 humidity and temperature sensor driver");
	310	MODULE_LICENSE("GPL");