[deliverable/linux.git] / drivers / iio / chemical / vz89x.c

/*
 * vz89x.c - Support for SGX Sensortech MiCS VZ89X VOC sensors
 *
 * Copyright (C) 2015 Matt Ranostay <mranostay@gmail.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.
 *
 */

#include <linux/module.h>
#include <linux/mutex.h>
#include <linux/init.h>
#include <linux/i2c.h>

#include <linux/iio/iio.h>
#include <linux/iio/sysfs.h>

#define VZ89X_REG_MEASUREMENT		0x09
#define VZ89X_REG_MEASUREMENT_SIZE	6

#define VZ89X_VOC_CO2_IDX		0
#define VZ89X_VOC_SHORT_IDX		1
#define VZ89X_VOC_TVOC_IDX		2
#define VZ89X_VOC_RESISTANCE_IDX	3

struct vz89x_data {
	struct i2c_client *client;
	struct mutex lock;
	int (*xfer)(struct vz89x_data *data, u8 cmd);

	unsigned long last_update;
	u8 buffer[VZ89X_REG_MEASUREMENT_SIZE];
};

static const struct iio_chan_spec vz89x_channels[] = {
	{
		.type = IIO_CONCENTRATION,
		.channel2 = IIO_MOD_CO2,
		.modified = 1,
		.info_mask_separate =
			BIT(IIO_CHAN_INFO_OFFSET) | BIT(IIO_CHAN_INFO_RAW),
		.address = VZ89X_VOC_CO2_IDX,
	},
	{
		.type = IIO_CONCENTRATION,
		.channel2 = IIO_MOD_VOC,
		.modified = 1,
		.info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
		.address = VZ89X_VOC_SHORT_IDX,
		.extend_name = "short",
	},
	{
		.type = IIO_CONCENTRATION,
		.channel2 = IIO_MOD_VOC,
		.modified = 1,
		.info_mask_separate =
			BIT(IIO_CHAN_INFO_OFFSET) | BIT(IIO_CHAN_INFO_RAW),
		.address = VZ89X_VOC_TVOC_IDX,
	},
	{
		.type = IIO_RESISTANCE,
		.info_mask_separate =
			BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
		.address = VZ89X_VOC_RESISTANCE_IDX,
	},
};

static IIO_CONST_ATTR(in_concentration_co2_scale, "0.00000698689");
static IIO_CONST_ATTR(in_concentration_voc_scale, "0.00000000436681223");

static struct attribute *vz89x_attributes[] = {
	&iio_const_attr_in_concentration_co2_scale.dev_attr.attr,
	&iio_const_attr_in_concentration_voc_scale.dev_attr.attr,
	NULL,
};

static const struct attribute_group vz89x_attrs_group = {
	.attrs = vz89x_attributes,
};

/*
 * Chipset sometime updates in the middle of a reading causing it to reset the
 * data pointer, and causing invalid reading of previous data.
 * We can check for this by reading MSB of the resistance reading that is
 * always zero, and by also confirming the VOC_short isn't zero.
 */

static int vz89x_measurement_is_valid(struct vz89x_data *data)
{
	if (data->buffer[VZ89X_VOC_SHORT_IDX] == 0)
		return 1;

	return !!(data->buffer[VZ89X_REG_MEASUREMENT_SIZE - 1] > 0);
}

static int vz89x_i2c_xfer(struct vz89x_data *data, u8 cmd)
{
	struct i2c_client *client = data->client;
	struct i2c_msg msg[2];
	int ret;
	u8 buf[3] = { cmd, 0, 0};

	msg[0].addr = client->addr;
	msg[0].flags = client->flags;
	msg[0].len = 3;
	msg[0].buf  = (char *) &buf;

	msg[1].addr = client->addr;
	msg[1].flags = client->flags | I2C_M_RD;
	msg[1].len = VZ89X_REG_MEASUREMENT_SIZE;
	msg[1].buf = (char *) &data->buffer;

	ret = i2c_transfer(client->adapter, msg, 2);

	return (ret == 2) ? 0 : ret;
}

static int vz89x_smbus_xfer(struct vz89x_data *data, u8 cmd)
{
	struct i2c_client *client = data->client;
	int ret;
	int i;

	ret = i2c_smbus_write_word_data(client, cmd, 0);
	if (ret < 0)
		return ret;

	for (i = 0; i < VZ89X_REG_MEASUREMENT_SIZE; i++) {
		ret = i2c_smbus_read_byte(client);
		if (ret < 0)
			return ret;
		data->buffer[i] = ret;
	}

	return 0;
}

static int vz89x_get_measurement(struct vz89x_data *data)
{
	int ret;

	/* sensor can only be polled once a second max per datasheet */
	if (!time_after(jiffies, data->last_update + HZ))
		return 0;

	ret = data->xfer(data, VZ89X_REG_MEASUREMENT);
	if (ret < 0)
		return ret;

	ret = vz89x_measurement_is_valid(data);
	if (ret)
		return -EAGAIN;

	data->last_update = jiffies;

	return 0;
}

static int vz89x_get_resistance_reading(struct vz89x_data *data)
{
	u8 *buf = &data->buffer[VZ89X_VOC_RESISTANCE_IDX];

	return buf[0] | (buf[1] << 8);
}

static int vz89x_read_raw(struct iio_dev *indio_dev,
			  struct iio_chan_spec const *chan, int *val,
			  int *val2, long mask)
{
	struct vz89x_data *data = iio_priv(indio_dev);
	int ret = -EINVAL;

	switch (mask) {
	case IIO_CHAN_INFO_RAW:
		mutex_lock(&data->lock);
		ret = vz89x_get_measurement(data);
		mutex_unlock(&data->lock);

		if (ret)
			return ret;

		switch (chan->address) {
		case VZ89X_VOC_CO2_IDX:
		case VZ89X_VOC_SHORT_IDX:
		case VZ89X_VOC_TVOC_IDX:
			*val = data->buffer[chan->address];
			return IIO_VAL_INT;
		case VZ89X_VOC_RESISTANCE_IDX:
			*val = vz89x_get_resistance_reading(data);
			return IIO_VAL_INT;
		default:
			return -EINVAL;
		}
		break;
	case IIO_CHAN_INFO_SCALE:
		switch (chan->type) {
		case IIO_RESISTANCE:
			*val = 10;
			return IIO_VAL_INT;
		default:
			return -EINVAL;
		}
		break;
	case IIO_CHAN_INFO_OFFSET:
		switch (chan->address) {
		case VZ89X_VOC_CO2_IDX:
			*val = 44;
			*val2 = 250000;
			return IIO_VAL_INT_PLUS_MICRO;
		case VZ89X_VOC_TVOC_IDX:
			*val = -13;
			return IIO_VAL_INT;
		default:
			return -EINVAL;
		}
	}

	return ret;
}

static const struct iio_info vz89x_info = {
	.attrs		= &vz89x_attrs_group,
	.read_raw	= vz89x_read_raw,
	.driver_module	= THIS_MODULE,
};

static int vz89x_probe(struct i2c_client *client,
		       const struct i2c_device_id *id)
{
	struct iio_dev *indio_dev;
	struct vz89x_data *data;

	indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
	if (!indio_dev)
		return -ENOMEM;
	data = iio_priv(indio_dev);

	if (i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
		data->xfer = vz89x_i2c_xfer;
	else if (i2c_check_functionality(client->adapter,
				I2C_FUNC_SMBUS_WORD_DATA | I2C_FUNC_SMBUS_BYTE))
		data->xfer = vz89x_smbus_xfer;
	else
		return -EOPNOTSUPP;

	i2c_set_clientdata(client, indio_dev);
	data->client = client;
	data->last_update = jiffies - HZ;
	mutex_init(&data->lock);

	indio_dev->dev.parent = &client->dev;
	indio_dev->info = &vz89x_info,
	indio_dev->name = dev_name(&client->dev);
	indio_dev->modes = INDIO_DIRECT_MODE;

	indio_dev->channels = vz89x_channels;
	indio_dev->num_channels = ARRAY_SIZE(vz89x_channels);

	return devm_iio_device_register(&client->dev, indio_dev);
}

static const struct i2c_device_id vz89x_id[] = {
	{ "vz89x", 0 },
	{ }
};
MODULE_DEVICE_TABLE(i2c, vz89x_id);

static const struct of_device_id vz89x_dt_ids[] = {
	{ .compatible = "sgx,vz89x" },
	{ }
};
MODULE_DEVICE_TABLE(of, vz89x_dt_ids);

static struct i2c_driver vz89x_driver = {
	.driver = {
		.name	= "vz89x",
		.of_match_table = of_match_ptr(vz89x_dt_ids),
	},
	.probe = vz89x_probe,
	.id_table = vz89x_id,
};
module_i2c_driver(vz89x_driver);

MODULE_AUTHOR("Matt Ranostay <mranostay@gmail.com>");
MODULE_DESCRIPTION("SGX Sensortech MiCS VZ89X VOC sensors");
MODULE_LICENSE("GPL v2");
Commit	Line	Data
cd8d9777 MR	1	/*
	2	* vz89x.c - Support for SGX Sensortech MiCS VZ89X VOC sensors
	3	*
	4	* Copyright (C) 2015 Matt Ranostay <mranostay@gmail.com>
	5	*
	6	* This program is free software; you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License as published by
	8	* the Free Software Foundation; either version 2 of the License, or
	9	* (at your option) any later version.
	10	*
	11	* This program is distributed in the hope that it will be useful,
	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	* GNU General Public License for more details.
	15	*
	16	*/
	17
	18	#include <linux/module.h>
	19	#include <linux/mutex.h>
	20	#include <linux/init.h>
	21	#include <linux/i2c.h>
	22
	23	#include <linux/iio/iio.h>
	24	#include <linux/iio/sysfs.h>
	25
	26	#define VZ89X_REG_MEASUREMENT 0x09
	27	#define VZ89X_REG_MEASUREMENT_SIZE 6
	28
	29	#define VZ89X_VOC_CO2_IDX 0
	30	#define VZ89X_VOC_SHORT_IDX 1
	31	#define VZ89X_VOC_TVOC_IDX 2
	32	#define VZ89X_VOC_RESISTANCE_IDX 3
	33
	34	struct vz89x_data {
	35	struct i2c_client *client;
	36	struct mutex lock;
93e87d73	37	int (xfer)(struct vz89x_data data, u8 cmd);
cd8d9777	38
93e87d73	39	unsigned long last_update;
cd8d9777 MR	40	u8 buffer[VZ89X_REG_MEASUREMENT_SIZE];
	41	};
	42
	43	static const struct iio_chan_spec vz89x_channels[] = {
	44	{
	45	.type = IIO_CONCENTRATION,
	46	.channel2 = IIO_MOD_CO2,
	47	.modified = 1,
	48	.info_mask_separate =
	49	BIT(IIO_CHAN_INFO_OFFSET) \| BIT(IIO_CHAN_INFO_RAW),
	50	.address = VZ89X_VOC_CO2_IDX,
	51	},
	52	{
	53	.type = IIO_CONCENTRATION,
	54	.channel2 = IIO_MOD_VOC,
	55	.modified = 1,
	56	.info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
	57	.address = VZ89X_VOC_SHORT_IDX,
	58	.extend_name = "short",
	59	},
	60	{
	61	.type = IIO_CONCENTRATION,
	62	.channel2 = IIO_MOD_VOC,
	63	.modified = 1,
	64	.info_mask_separate =
	65	BIT(IIO_CHAN_INFO_OFFSET) \| BIT(IIO_CHAN_INFO_RAW),
	66	.address = VZ89X_VOC_TVOC_IDX,
	67	},
	68	{
	69	.type = IIO_RESISTANCE,
	70	.info_mask_separate =
	71	BIT(IIO_CHAN_INFO_RAW) \| BIT(IIO_CHAN_INFO_SCALE),
	72	.address = VZ89X_VOC_RESISTANCE_IDX,
	73	},
	74	};
	75
	76	static IIO_CONST_ATTR(in_concentration_co2_scale, "0.00000698689");
	77	static IIO_CONST_ATTR(in_concentration_voc_scale, "0.00000000436681223");
	78
	79	static struct attribute *vz89x_attributes[] = {
	80	&iio_const_attr_in_concentration_co2_scale.dev_attr.attr,
	81	&iio_const_attr_in_concentration_voc_scale.dev_attr.attr,
	82	NULL,
	83	};
	84
	85	static const struct attribute_group vz89x_attrs_group = {
	86	.attrs = vz89x_attributes,
	87	};
	88
bf23cee6 MR	89	/*
	90	* Chipset sometime updates in the middle of a reading causing it to reset the
	91	* data pointer, and causing invalid reading of previous data.
	92	* We can check for this by reading MSB of the resistance reading that is
	93	* always zero, and by also confirming the VOC_short isn't zero.
	94	*/
	95
	96	static int vz89x_measurement_is_valid(struct vz89x_data *data)
	97	{
	98	if (data->buffer[VZ89X_VOC_SHORT_IDX] == 0)
	99	return 1;
	100
	101	return !!(data->buffer[VZ89X_REG_MEASUREMENT_SIZE - 1] > 0);
	102	}
	103
93e87d73	104	static int vz89x_i2c_xfer(struct vz89x_data *data, u8 cmd)
cd8d9777	105	{
93e87d73 MR	106	struct i2c_client *client = data->client;
93e87d73 MR	107	struct i2c_msg msg[2];
cd8d9777	108	int ret;
93e87d73	109	u8 buf[3] = { cmd, 0, 0};
cd8d9777	110
93e87d73 MR	111	msg[0].addr = client->addr;
	112	msg[0].flags = client->flags;
	113	msg[0].len = 3;
	114	msg[0].buf = (char *) &buf;
	115
	116	msg[1].addr = client->addr;
	117	msg[1].flags = client->flags \| I2C_M_RD;
	118	msg[1].len = VZ89X_REG_MEASUREMENT_SIZE;
	119	msg[1].buf = (char *) &data->buffer;
	120
	121	ret = i2c_transfer(client->adapter, msg, 2);
cd8d9777	122
93e87d73 MR	123	return (ret == 2) ? 0 : ret;
	124	}
	125
	126	static int vz89x_smbus_xfer(struct vz89x_data *data, u8 cmd)
	127	{
	128	struct i2c_client *client = data->client;
	129	int ret;
	130	int i;
	131
	132	ret = i2c_smbus_write_word_data(client, cmd, 0);
cd8d9777 MR	133	if (ret < 0)
	134	return ret;
	135
	136	for (i = 0; i < VZ89X_REG_MEASUREMENT_SIZE; i++) {
93e87d73	137	ret = i2c_smbus_read_byte(client);
cd8d9777 MR	138	if (ret < 0)
	139	return ret;
	140	data->buffer[i] = ret;
	141	}
	142
93e87d73 MR	143	return 0;
	144	}
	145
	146	static int vz89x_get_measurement(struct vz89x_data *data)
	147	{
	148	int ret;
	149
	150	/* sensor can only be polled once a second max per datasheet */
	151	if (!time_after(jiffies, data->last_update + HZ))
	152	return 0;
	153
	154	ret = data->xfer(data, VZ89X_REG_MEASUREMENT);
	155	if (ret < 0)
	156	return ret;
	157
bf23cee6 MR	158	ret = vz89x_measurement_is_valid(data);
	159	if (ret)
	160	return -EAGAIN;
	161
cd8d9777 MR	162	data->last_update = jiffies;
	163
	164	return 0;
	165	}
	166
	167	static int vz89x_get_resistance_reading(struct vz89x_data *data)
	168	{
bf23cee6	169	u8 *buf = &data->buffer[VZ89X_VOC_RESISTANCE_IDX];
cd8d9777	170
bf23cee6	171	return buf[0] \| (buf[1] << 8);
cd8d9777 MR	172	}
	173
	174	static int vz89x_read_raw(struct iio_dev *indio_dev,
	175	struct iio_chan_spec const chan, int val,
	176	int *val2, long mask)
	177	{
	178	struct vz89x_data *data = iio_priv(indio_dev);
	179	int ret = -EINVAL;
	180
	181	switch (mask) {
	182	case IIO_CHAN_INFO_RAW:
	183	mutex_lock(&data->lock);
	184	ret = vz89x_get_measurement(data);
	185	mutex_unlock(&data->lock);
	186
	187	if (ret)
	188	return ret;
	189
	190	switch (chan->address) {
	191	case VZ89X_VOC_CO2_IDX:
	192	case VZ89X_VOC_SHORT_IDX:
	193	case VZ89X_VOC_TVOC_IDX:
	194	*val = data->buffer[chan->address];
	195	return IIO_VAL_INT;
	196	case VZ89X_VOC_RESISTANCE_IDX:
	197	*val = vz89x_get_resistance_reading(data);
	198	return IIO_VAL_INT;
	199	default:
	200	return -EINVAL;
	201	}
	202	break;
	203	case IIO_CHAN_INFO_SCALE:
	204	switch (chan->type) {
	205	case IIO_RESISTANCE:
	206	*val = 10;
	207	return IIO_VAL_INT;
	208	default:
	209	return -EINVAL;
	210	}
	211	break;
	212	case IIO_CHAN_INFO_OFFSET:
	213	switch (chan->address) {
	214	case VZ89X_VOC_CO2_IDX:
	215	*val = 44;
	216	*val2 = 250000;
	217	return IIO_VAL_INT_PLUS_MICRO;
	218	case VZ89X_VOC_TVOC_IDX:
	219	*val = -13;
	220	return IIO_VAL_INT;
	221	default:
	222	return -EINVAL;
	223	}
	224	}
	225
	226	return ret;
	227	}
	228
	229	static const struct iio_info vz89x_info = {
	230	.attrs = &vz89x_attrs_group,
	231	.read_raw = vz89x_read_raw,
	232	.driver_module = THIS_MODULE,
	233	};
	234
	235	static int vz89x_probe(struct i2c_client *client,
236	const struct i2c_device_id *id)
237	{
238	struct iio_dev *indio_dev;
239	struct vz89x_data *data;
240
cd8d9777 MR	241	indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
	242	if (!indio_dev)
	243	return -ENOMEM;
cd8d9777	244	data = iio_priv(indio_dev);
93e87d73 MR	245
	246	if (i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
	247	data->xfer = vz89x_i2c_xfer;
	248	else if (i2c_check_functionality(client->adapter,
	249	I2C_FUNC_SMBUS_WORD_DATA \| I2C_FUNC_SMBUS_BYTE))
	250	data->xfer = vz89x_smbus_xfer;
	251	else
f8d9d3b4	252	return -EOPNOTSUPP;
93e87d73	253
cd8d9777 MR	254	i2c_set_clientdata(client, indio_dev);
	255	data->client = client;
	256	data->last_update = jiffies - HZ;
	257	mutex_init(&data->lock);
	258
	259	indio_dev->dev.parent = &client->dev;
	260	indio_dev->info = &vz89x_info,
	261	indio_dev->name = dev_name(&client->dev);
	262	indio_dev->modes = INDIO_DIRECT_MODE;
	263
	264	indio_dev->channels = vz89x_channels;
	265	indio_dev->num_channels = ARRAY_SIZE(vz89x_channels);
	266
	267	return devm_iio_device_register(&client->dev, indio_dev);
	268	}
	269
	270	static const struct i2c_device_id vz89x_id[] = {
	271	{ "vz89x", 0 },
	272	{ }
	273	};
	274	MODULE_DEVICE_TABLE(i2c, vz89x_id);
	275
	276	static const struct of_device_id vz89x_dt_ids[] = {
	277	{ .compatible = "sgx,vz89x" },
	278	{ }
	279	};
	280	MODULE_DEVICE_TABLE(of, vz89x_dt_ids);
	281
	282	static struct i2c_driver vz89x_driver = {
	283	.driver = {
	284	.name = "vz89x",
	285	.of_match_table = of_match_ptr(vz89x_dt_ids),
	286	},
	287	.probe = vz89x_probe,
	288	.id_table = vz89x_id,
	289	};
	290	module_i2c_driver(vz89x_driver);
	291
	292	MODULE_AUTHOR("Matt Ranostay <mranostay@gmail.com>");
	293	MODULE_DESCRIPTION("SGX Sensortech MiCS VZ89X VOC sensors");
	294	MODULE_LICENSE("GPL v2");