[mirror_ubuntu-jammy-kernel.git] / drivers / iio / chemical / sps30.c

// SPDX-License-Identifier: GPL-2.0
/*
 * Sensirion SPS30 particulate matter sensor driver
 *
 * Copyright (c) Tomasz Duszynski <tduszyns@gmail.com>
 *
 * I2C slave address: 0x69
 */

#include <asm/unaligned.h>
#include <linux/crc8.h>
#include <linux/delay.h>
#include <linux/i2c.h>
#include <linux/iio/buffer.h>
#include <linux/iio/iio.h>
#include <linux/iio/sysfs.h>
#include <linux/iio/trigger_consumer.h>
#include <linux/iio/triggered_buffer.h>
#include <linux/kernel.h>
#include <linux/module.h>

#define SPS30_CRC8_POLYNOMIAL 0x31
/* max number of bytes needed to store PM measurements or serial string */
#define SPS30_MAX_READ_SIZE 48
/* sensor measures reliably up to 3000 ug / m3 */
#define SPS30_MAX_PM 3000
/* minimum and maximum self cleaning periods in seconds */
#define SPS30_AUTO_CLEANING_PERIOD_MIN 0
#define SPS30_AUTO_CLEANING_PERIOD_MAX 604800

/* SPS30 commands */
#define SPS30_START_MEAS 0x0010
#define SPS30_STOP_MEAS 0x0104
#define SPS30_RESET 0xd304
#define SPS30_READ_DATA_READY_FLAG 0x0202
#define SPS30_READ_DATA 0x0300
#define SPS30_READ_SERIAL 0xd033
#define SPS30_START_FAN_CLEANING 0x5607
#define SPS30_AUTO_CLEANING_PERIOD 0x8004
/* not a sensor command per se, used only to distinguish write from read */
#define SPS30_READ_AUTO_CLEANING_PERIOD 0x8005

enum {
	PM1,
	PM2P5,
	PM4,
	PM10,
};

enum {
	RESET,
	MEASURING,
};

struct sps30_state {
	struct i2c_client *client;
	/*
	 * Guards against concurrent access to sensor registers.
	 * Must be held whenever sequence of commands is to be executed.
	 */
	struct mutex lock;
	int state;
};

DECLARE_CRC8_TABLE(sps30_crc8_table);

static int sps30_write_then_read(struct sps30_state *state, u8 *txbuf,
				 int txsize, u8 *rxbuf, int rxsize)
{
	int ret;

	/*
	 * Sensor does not support repeated start so instead of
	 * sending two i2c messages in a row we just send one by one.
	 */
	ret = i2c_master_send(state->client, txbuf, txsize);
	if (ret != txsize)
		return ret < 0 ? ret : -EIO;

	if (!rxbuf)
		return 0;

	ret = i2c_master_recv(state->client, rxbuf, rxsize);
	if (ret != rxsize)
		return ret < 0 ? ret : -EIO;

	return 0;
}

static int sps30_do_cmd(struct sps30_state *state, u16 cmd, u8 *data, int size)
{
	/*
	 * Internally sensor stores measurements in a following manner:
	 *
	 * PM1: upper two bytes, crc8, lower two bytes, crc8
	 * PM2P5: upper two bytes, crc8, lower two bytes, crc8
	 * PM4: upper two bytes, crc8, lower two bytes, crc8
	 * PM10: upper two bytes, crc8, lower two bytes, crc8
	 *
	 * What follows next are number concentration measurements and
	 * typical particle size measurement which we omit.
	 */
	u8 buf[SPS30_MAX_READ_SIZE] = { cmd >> 8, cmd };
	int i, ret = 0;

	switch (cmd) {
	case SPS30_START_MEAS:
		buf[2] = 0x03;
		buf[3] = 0x00;
		buf[4] = crc8(sps30_crc8_table, &buf[2], 2, CRC8_INIT_VALUE);
		ret = sps30_write_then_read(state, buf, 5, NULL, 0);
		break;
	case SPS30_STOP_MEAS:
	case SPS30_RESET:
	case SPS30_START_FAN_CLEANING:
		ret = sps30_write_then_read(state, buf, 2, NULL, 0);
		break;
	case SPS30_READ_AUTO_CLEANING_PERIOD:
		buf[0] = SPS30_AUTO_CLEANING_PERIOD >> 8;
		buf[1] = (u8)(SPS30_AUTO_CLEANING_PERIOD & 0xff);
		fallthrough;
	case SPS30_READ_DATA_READY_FLAG:
	case SPS30_READ_DATA:
	case SPS30_READ_SERIAL:
		/* every two data bytes are checksummed */
		size += size / 2;
		ret = sps30_write_then_read(state, buf, 2, buf, size);
		break;
	case SPS30_AUTO_CLEANING_PERIOD:
		buf[2] = data[0];
		buf[3] = data[1];
		buf[4] = crc8(sps30_crc8_table, &buf[2], 2, CRC8_INIT_VALUE);
		buf[5] = data[2];
		buf[6] = data[3];
		buf[7] = crc8(sps30_crc8_table, &buf[5], 2, CRC8_INIT_VALUE);
		ret = sps30_write_then_read(state, buf, 8, NULL, 0);
		break;
	}

	if (ret)
		return ret;

	/* validate received data and strip off crc bytes */
	for (i = 0; i < size; i += 3) {
		u8 crc = crc8(sps30_crc8_table, &buf[i], 2, CRC8_INIT_VALUE);

		if (crc != buf[i + 2]) {
			dev_err(&state->client->dev,
				"data integrity check failed\n");
			return -EIO;
		}

		*data++ = buf[i];
		*data++ = buf[i + 1];
	}

	return 0;
}

static s32 sps30_float_to_int_clamped(const u8 *fp)
{
	int val = get_unaligned_be32(fp);
	int mantissa = val & GENMASK(22, 0);
	/* this is fine since passed float is always non-negative */
	int exp = val >> 23;
	int fraction, shift;

	/* special case 0 */
	if (!exp && !mantissa)
		return 0;

	exp -= 127;
	if (exp < 0) {
		/* return values ranging from 1 to 99 */
		return ((((1 << 23) + mantissa) * 100) >> 23) >> (-exp);
	}

	/* return values ranging from 100 to 300000 */
	shift = 23 - exp;
	val = (1 << exp) + (mantissa >> shift);
	if (val >= SPS30_MAX_PM)
		return SPS30_MAX_PM * 100;

	fraction = mantissa & GENMASK(shift - 1, 0);

	return val * 100 + ((fraction * 100) >> shift);
}

static int sps30_do_meas(struct sps30_state *state, s32 *data, int size)
{
	int i, ret, tries = 5;
	u8 tmp[16];

	if (state->state == RESET) {
		ret = sps30_do_cmd(state, SPS30_START_MEAS, NULL, 0);
		if (ret)
			return ret;

		state->state = MEASURING;
	}

	while (tries--) {
		ret = sps30_do_cmd(state, SPS30_READ_DATA_READY_FLAG, tmp, 2);
		if (ret)
			return -EIO;

		/* new measurements ready to be read */
		if (tmp[1] == 1)
			break;

		msleep_interruptible(300);
	}

	if (tries == -1)
		return -ETIMEDOUT;

	ret = sps30_do_cmd(state, SPS30_READ_DATA, tmp, sizeof(int) * size);
	if (ret)
		return ret;

	for (i = 0; i < size; i++)
		data[i] = sps30_float_to_int_clamped(&tmp[4 * i]);

	return 0;
}

static irqreturn_t sps30_trigger_handler(int irq, void *p)
{
	struct iio_poll_func *pf = p;
	struct iio_dev *indio_dev = pf->indio_dev;
	struct sps30_state *state = iio_priv(indio_dev);
	int ret;
	struct {
		s32 data[4]; /* PM1, PM2P5, PM4, PM10 */
		s64 ts;
	} scan;

	mutex_lock(&state->lock);
	ret = sps30_do_meas(state, scan.data, ARRAY_SIZE(scan.data));
	mutex_unlock(&state->lock);
	if (ret)
		goto err;

	iio_push_to_buffers_with_timestamp(indio_dev, &scan,
					   iio_get_time_ns(indio_dev));
err:
	iio_trigger_notify_done(indio_dev->trig);

	return IRQ_HANDLED;
}

static int sps30_read_raw(struct iio_dev *indio_dev,
			  struct iio_chan_spec const *chan,
			  int *val, int *val2, long mask)
{
	struct sps30_state *state = iio_priv(indio_dev);
	int data[4], ret = -EINVAL;

	switch (mask) {
	case IIO_CHAN_INFO_PROCESSED:
		switch (chan->type) {
		case IIO_MASSCONCENTRATION:
			mutex_lock(&state->lock);
			/* read up to the number of bytes actually needed */
			switch (chan->channel2) {
			case IIO_MOD_PM1:
				ret = sps30_do_meas(state, data, 1);
				break;
			case IIO_MOD_PM2P5:
				ret = sps30_do_meas(state, data, 2);
				break;
			case IIO_MOD_PM4:
				ret = sps30_do_meas(state, data, 3);
				break;
			case IIO_MOD_PM10:
				ret = sps30_do_meas(state, data, 4);
				break;
			}
			mutex_unlock(&state->lock);
			if (ret)
				return ret;

			*val = data[chan->address] / 100;
			*val2 = (data[chan->address] % 100) * 10000;

			return IIO_VAL_INT_PLUS_MICRO;
		default:
			return -EINVAL;
		}
	case IIO_CHAN_INFO_SCALE:
		switch (chan->type) {
		case IIO_MASSCONCENTRATION:
			switch (chan->channel2) {
			case IIO_MOD_PM1:
			case IIO_MOD_PM2P5:
			case IIO_MOD_PM4:
			case IIO_MOD_PM10:
				*val = 0;
				*val2 = 10000;

				return IIO_VAL_INT_PLUS_MICRO;
			default:
				return -EINVAL;
			}
		default:
			return -EINVAL;
		}
	}

	return -EINVAL;
}

static int sps30_do_cmd_reset(struct sps30_state *state)
{
	int ret;

	ret = sps30_do_cmd(state, SPS30_RESET, NULL, 0);
	msleep(300);
	/*
	 * Power-on-reset causes sensor to produce some glitch on i2c bus and
	 * some controllers end up in error state. Recover simply by placing
	 * some data on the bus, for example STOP_MEAS command, which
	 * is NOP in this case.
	 */
	sps30_do_cmd(state, SPS30_STOP_MEAS, NULL, 0);
	state->state = RESET;

	return ret;
}

static ssize_t start_cleaning_store(struct device *dev,
				    struct device_attribute *attr,
				    const char *buf, size_t len)
{
	struct iio_dev *indio_dev = dev_to_iio_dev(dev);
	struct sps30_state *state = iio_priv(indio_dev);
	int val, ret;

	if (kstrtoint(buf, 0, &val) || val != 1)
		return -EINVAL;

	mutex_lock(&state->lock);
	ret = sps30_do_cmd(state, SPS30_START_FAN_CLEANING, NULL, 0);
	mutex_unlock(&state->lock);
	if (ret)
		return ret;

	return len;
}

static ssize_t cleaning_period_show(struct device *dev,
				      struct device_attribute *attr,
				      char *buf)
{
	struct iio_dev *indio_dev = dev_to_iio_dev(dev);
	struct sps30_state *state = iio_priv(indio_dev);
	u8 tmp[4];
	int ret;

	mutex_lock(&state->lock);
	ret = sps30_do_cmd(state, SPS30_READ_AUTO_CLEANING_PERIOD, tmp, 4);
	mutex_unlock(&state->lock);
	if (ret)
		return ret;

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

static ssize_t cleaning_period_store(struct device *dev,
				       struct device_attribute *attr,
				       const char *buf, size_t len)
{
	struct iio_dev *indio_dev = dev_to_iio_dev(dev);
	struct sps30_state *state = iio_priv(indio_dev);
	int val, ret;
	u8 tmp[4];

	if (kstrtoint(buf, 0, &val))
		return -EINVAL;

	if ((val < SPS30_AUTO_CLEANING_PERIOD_MIN) ||
	    (val > SPS30_AUTO_CLEANING_PERIOD_MAX))
		return -EINVAL;

	put_unaligned_be32(val, tmp);

	mutex_lock(&state->lock);
	ret = sps30_do_cmd(state, SPS30_AUTO_CLEANING_PERIOD, tmp, 0);
	if (ret) {
		mutex_unlock(&state->lock);
		return ret;
	}

	msleep(20);

	/*
	 * sensor requires reset in order to return up to date self cleaning
	 * period
	 */
	ret = sps30_do_cmd_reset(state);
	if (ret)
		dev_warn(dev,
			 "period changed but reads will return the old value\n");

	mutex_unlock(&state->lock);

	return len;
}

static ssize_t cleaning_period_available_show(struct device *dev,
					      struct device_attribute *attr,
					      char *buf)
{
	return snprintf(buf, PAGE_SIZE, "[%d %d %d]\n",
			SPS30_AUTO_CLEANING_PERIOD_MIN, 1,
			SPS30_AUTO_CLEANING_PERIOD_MAX);
}

static IIO_DEVICE_ATTR_WO(start_cleaning, 0);
static IIO_DEVICE_ATTR_RW(cleaning_period, 0);
static IIO_DEVICE_ATTR_RO(cleaning_period_available, 0);

static struct attribute *sps30_attrs[] = {
	&iio_dev_attr_start_cleaning.dev_attr.attr,
	&iio_dev_attr_cleaning_period.dev_attr.attr,
	&iio_dev_attr_cleaning_period_available.dev_attr.attr,
	NULL
};

static const struct attribute_group sps30_attr_group = {
	.attrs = sps30_attrs,
};

static const struct iio_info sps30_info = {
	.attrs = &sps30_attr_group,
	.read_raw = sps30_read_raw,
};

#define SPS30_CHAN(_index, _mod) { \
	.type = IIO_MASSCONCENTRATION, \
	.modified = 1, \
	.channel2 = IIO_MOD_ ## _mod, \
	.info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED), \
	.info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE), \
	.address = _mod, \
	.scan_index = _index, \
	.scan_type = { \
		.sign = 'u', \
		.realbits = 19, \
		.storagebits = 32, \
		.endianness = IIO_CPU, \
	}, \
}

static const struct iio_chan_spec sps30_channels[] = {
	SPS30_CHAN(0, PM1),
	SPS30_CHAN(1, PM2P5),
	SPS30_CHAN(2, PM4),
	SPS30_CHAN(3, PM10),
	IIO_CHAN_SOFT_TIMESTAMP(4),
};

static void sps30_stop_meas(void *data)
{
	struct sps30_state *state = data;

	sps30_do_cmd(state, SPS30_STOP_MEAS, NULL, 0);
}

static const unsigned long sps30_scan_masks[] = { 0x0f, 0x00 };

static int sps30_probe(struct i2c_client *client)
{
	struct iio_dev *indio_dev;
	struct sps30_state *state;
	u8 buf[32];
	int ret;

	if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
		return -EOPNOTSUPP;

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

	state = iio_priv(indio_dev);
	i2c_set_clientdata(client, indio_dev);
	state->client = client;
	state->state = RESET;
	indio_dev->info = &sps30_info;
	indio_dev->name = client->name;
	indio_dev->channels = sps30_channels;
	indio_dev->num_channels = ARRAY_SIZE(sps30_channels);
	indio_dev->modes = INDIO_DIRECT_MODE;
	indio_dev->available_scan_masks = sps30_scan_masks;

	mutex_init(&state->lock);
	crc8_populate_msb(sps30_crc8_table, SPS30_CRC8_POLYNOMIAL);

	ret = sps30_do_cmd_reset(state);
	if (ret) {
		dev_err(&client->dev, "failed to reset device\n");
		return ret;
	}

	ret = sps30_do_cmd(state, SPS30_READ_SERIAL, buf, sizeof(buf));
	if (ret) {
		dev_err(&client->dev, "failed to read serial number\n");
		return ret;
	}
	/* returned serial number is already NUL terminated */
	dev_info(&client->dev, "serial number: %s\n", buf);

	ret = devm_add_action_or_reset(&client->dev, sps30_stop_meas, state);
	if (ret)
		return ret;

	ret = devm_iio_triggered_buffer_setup(&client->dev, indio_dev, NULL,
					      sps30_trigger_handler, NULL);
	if (ret)
		return ret;

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

static const struct i2c_device_id sps30_id[] = {
	{ "sps30" },
	{ }
};
MODULE_DEVICE_TABLE(i2c, sps30_id);

static const struct of_device_id sps30_of_match[] = {
	{ .compatible = "sensirion,sps30" },
	{ }
};
MODULE_DEVICE_TABLE(of, sps30_of_match);

static struct i2c_driver sps30_driver = {
	.driver = {
		.name = "sps30",
		.of_match_table = sps30_of_match,
	},
	.id_table = sps30_id,
	.probe_new = sps30_probe,
};
module_i2c_driver(sps30_driver);

MODULE_AUTHOR("Tomasz Duszynski <tduszyns@gmail.com>");
MODULE_DESCRIPTION("Sensirion SPS30 particulate matter sensor driver");
MODULE_LICENSE("GPL v2");
Commit	Line	Data
232e0f6d TD	1	// SPDX-License-Identifier: GPL-2.0
	2	/*
	3	* Sensirion SPS30 particulate matter sensor driver
	4	*
	5	* Copyright (c) Tomasz Duszynski <tduszyns@gmail.com>
	6	*
	7	* I2C slave address: 0x69
232e0f6d TD	8	*/
232e0f6d TD	9
232e0f6d TD	10	#include <asm/unaligned.h>
	11	#include <linux/crc8.h>
	12	#include <linux/delay.h>
	13	#include <linux/i2c.h>
	14	#include <linux/iio/buffer.h>
	15	#include <linux/iio/iio.h>
	16	#include <linux/iio/sysfs.h>
	17	#include <linux/iio/trigger_consumer.h>
	18	#include <linux/iio/triggered_buffer.h>
62129a08	19	#include <linux/kernel.h>
232e0f6d TD	20	#include <linux/module.h>
	21
	22	#define SPS30_CRC8_POLYNOMIAL 0x31
	23	/* max number of bytes needed to store PM measurements or serial string */
	24	#define SPS30_MAX_READ_SIZE 48
	25	/* sensor measures reliably up to 3000 ug / m3 */
	26	#define SPS30_MAX_PM 3000
62129a08 TD	27	/* minimum and maximum self cleaning periods in seconds */
	28	#define SPS30_AUTO_CLEANING_PERIOD_MIN 0
	29	#define SPS30_AUTO_CLEANING_PERIOD_MAX 604800
232e0f6d TD	30
	31	/* SPS30 commands */
	32	#define SPS30_START_MEAS 0x0010
	33	#define SPS30_STOP_MEAS 0x0104
	34	#define SPS30_RESET 0xd304
	35	#define SPS30_READ_DATA_READY_FLAG 0x0202
	36	#define SPS30_READ_DATA 0x0300
	37	#define SPS30_READ_SERIAL 0xd033
c546d496	38	#define SPS30_START_FAN_CLEANING 0x5607
62129a08 TD	39	#define SPS30_AUTO_CLEANING_PERIOD 0x8004
	40	/* not a sensor command per se, used only to distinguish write from read */
	41	#define SPS30_READ_AUTO_CLEANING_PERIOD 0x8005
232e0f6d TD	42
	43	enum {
	44	PM1,
	45	PM2P5,
	46	PM4,
	47	PM10,
	48	};
	49
62129a08 TD	50	enum {
	51	RESET,
	52	MEASURING,
	53	};
	54
232e0f6d TD	55	struct sps30_state {
	56	struct i2c_client *client;
	57	/*
	58	* Guards against concurrent access to sensor registers.
	59	* Must be held whenever sequence of commands is to be executed.
	60	*/
	61	struct mutex lock;
62129a08	62	int state;
232e0f6d TD	63	};
	64
	65	DECLARE_CRC8_TABLE(sps30_crc8_table);
	66
	67	static int sps30_write_then_read(struct sps30_state state, u8 txbuf,
	68	int txsize, u8 *rxbuf, int rxsize)
	69	{
	70	int ret;
	71
	72	/*
	73	* Sensor does not support repeated start so instead of
	74	* sending two i2c messages in a row we just send one by one.
	75	*/
	76	ret = i2c_master_send(state->client, txbuf, txsize);
	77	if (ret != txsize)
	78	return ret < 0 ? ret : -EIO;
	79
	80	if (!rxbuf)
	81	return 0;
	82
	83	ret = i2c_master_recv(state->client, rxbuf, rxsize);
	84	if (ret != rxsize)
	85	return ret < 0 ? ret : -EIO;
	86
	87	return 0;
	88	}
	89
	90	static int sps30_do_cmd(struct sps30_state state, u16 cmd, u8 data, int size)
	91	{
	92	/*
	93	* Internally sensor stores measurements in a following manner:
	94	*
	95	* PM1: upper two bytes, crc8, lower two bytes, crc8
	96	* PM2P5: upper two bytes, crc8, lower two bytes, crc8
	97	* PM4: upper two bytes, crc8, lower two bytes, crc8
	98	* PM10: upper two bytes, crc8, lower two bytes, crc8
	99	*
	100	* What follows next are number concentration measurements and
	101	* typical particle size measurement which we omit.
	102	*/
	103	u8 buf[SPS30_MAX_READ_SIZE] = { cmd >> 8, cmd };
	104	int i, ret = 0;
	105
	106	switch (cmd) {
	107	case SPS30_START_MEAS:
	108	buf[2] = 0x03;
	109	buf[3] = 0x00;
	110	buf[4] = crc8(sps30_crc8_table, &buf[2], 2, CRC8_INIT_VALUE);
	111	ret = sps30_write_then_read(state, buf, 5, NULL, 0);
	112	break;
	113	case SPS30_STOP_MEAS:
	114	case SPS30_RESET:
c546d496	115	case SPS30_START_FAN_CLEANING:
232e0f6d TD	116	ret = sps30_write_then_read(state, buf, 2, NULL, 0);
232e0f6d TD	117	break;
62129a08 TD	118	case SPS30_READ_AUTO_CLEANING_PERIOD:
62129a08 TD	119	buf[0] = SPS30_AUTO_CLEANING_PERIOD >> 8;
78b75ab3	120	buf[1] = (u8)(SPS30_AUTO_CLEANING_PERIOD & 0xff);
df561f66	121	fallthrough;
232e0f6d TD	122	case SPS30_READ_DATA_READY_FLAG:
	123	case SPS30_READ_DATA:
	124	case SPS30_READ_SERIAL:
	125	/* every two data bytes are checksummed */
	126	size += size / 2;
	127	ret = sps30_write_then_read(state, buf, 2, buf, size);
	128	break;
62129a08 TD	129	case SPS30_AUTO_CLEANING_PERIOD:
	130	buf[2] = data[0];
	131	buf[3] = data[1];
	132	buf[4] = crc8(sps30_crc8_table, &buf[2], 2, CRC8_INIT_VALUE);
	133	buf[5] = data[2];
	134	buf[6] = data[3];
	135	buf[7] = crc8(sps30_crc8_table, &buf[5], 2, CRC8_INIT_VALUE);
	136	ret = sps30_write_then_read(state, buf, 8, NULL, 0);
	137	break;
232e0f6d TD	138	}
	139
	140	if (ret)
	141	return ret;
	142
	143	/* validate received data and strip off crc bytes */
	144	for (i = 0; i < size; i += 3) {
	145	u8 crc = crc8(sps30_crc8_table, &buf[i], 2, CRC8_INIT_VALUE);
	146
	147	if (crc != buf[i + 2]) {
	148	dev_err(&state->client->dev,
	149	"data integrity check failed\n");
	150	return -EIO;
	151	}
	152
	153	*data++ = buf[i];
	154	*data++ = buf[i + 1];
	155	}
	156
	157	return 0;
	158	}
	159
	160	static s32 sps30_float_to_int_clamped(const u8 *fp)
	161	{
	162	int val = get_unaligned_be32(fp);
	163	int mantissa = val & GENMASK(22, 0);
	164	/* this is fine since passed float is always non-negative */
	165	int exp = val >> 23;
	166	int fraction, shift;
	167
	168	/* special case 0 */
	169	if (!exp && !mantissa)
	170	return 0;
	171
	172	exp -= 127;
	173	if (exp < 0) {
	174	/* return values ranging from 1 to 99 */
	175	return ((((1 << 23) + mantissa) * 100) >> 23) >> (-exp);
	176	}
	177
	178	/* return values ranging from 100 to 300000 */
	179	shift = 23 - exp;
	180	val = (1 << exp) + (mantissa >> shift);
	181	if (val >= SPS30_MAX_PM)
	182	return SPS30_MAX_PM * 100;
	183
	184	fraction = mantissa & GENMASK(shift - 1, 0);
	185
	186	return val * 100 + ((fraction * 100) >> shift);
	187	}
	188
	189	static int sps30_do_meas(struct sps30_state state, s32 data, int size)
	190	{
	191	int i, ret, tries = 5;
	192	u8 tmp[16];
	193
62129a08 TD	194	if (state->state == RESET) {
	195	ret = sps30_do_cmd(state, SPS30_START_MEAS, NULL, 0);
	196	if (ret)
	197	return ret;
	198
	199	state->state = MEASURING;
	200	}
	201
232e0f6d TD	202	while (tries--) {
	203	ret = sps30_do_cmd(state, SPS30_READ_DATA_READY_FLAG, tmp, 2);
	204	if (ret)
	205	return -EIO;
	206
	207	/* new measurements ready to be read */
	208	if (tmp[1] == 1)
	209	break;
	210
	211	msleep_interruptible(300);
	212	}
	213
905889b4	214	if (tries == -1)
232e0f6d TD	215	return -ETIMEDOUT;
	216
	217	ret = sps30_do_cmd(state, SPS30_READ_DATA, tmp, sizeof(int) * size);
	218	if (ret)
	219	return ret;
	220
	221	for (i = 0; i < size; i++)
	222	data[i] = sps30_float_to_int_clamped(&tmp[4 * i]);
	223
	224	return 0;
	225	}
	226
	227	static irqreturn_t sps30_trigger_handler(int irq, void *p)
	228	{
	229	struct iio_poll_func *pf = p;
	230	struct iio_dev *indio_dev = pf->indio_dev;
	231	struct sps30_state *state = iio_priv(indio_dev);
	232	int ret;
a5bf6fdd JC	233	struct {
	234	s32 data[4]; /* PM1, PM2P5, PM4, PM10 */
	235	s64 ts;
	236	} scan;
232e0f6d TD	237
232e0f6d TD	238	mutex_lock(&state->lock);
a5bf6fdd	239	ret = sps30_do_meas(state, scan.data, ARRAY_SIZE(scan.data));
232e0f6d TD	240	mutex_unlock(&state->lock);
	241	if (ret)
	242	goto err;
	243
a5bf6fdd	244	iio_push_to_buffers_with_timestamp(indio_dev, &scan,
232e0f6d TD	245	iio_get_time_ns(indio_dev));
	246	err:
	247	iio_trigger_notify_done(indio_dev->trig);
	248
	249	return IRQ_HANDLED;
	250	}
	251
	252	static int sps30_read_raw(struct iio_dev *indio_dev,
	253	struct iio_chan_spec const *chan,
	254	int val, int val2, long mask)
	255	{
	256	struct sps30_state *state = iio_priv(indio_dev);
	257	int data[4], ret = -EINVAL;
	258
	259	switch (mask) {
	260	case IIO_CHAN_INFO_PROCESSED:
	261	switch (chan->type) {
	262	case IIO_MASSCONCENTRATION:
	263	mutex_lock(&state->lock);
	264	/* read up to the number of bytes actually needed */
	265	switch (chan->channel2) {
	266	case IIO_MOD_PM1:
	267	ret = sps30_do_meas(state, data, 1);
	268	break;
	269	case IIO_MOD_PM2P5:
	270	ret = sps30_do_meas(state, data, 2);
	271	break;
	272	case IIO_MOD_PM4:
	273	ret = sps30_do_meas(state, data, 3);
	274	break;
	275	case IIO_MOD_PM10:
	276	ret = sps30_do_meas(state, data, 4);
	277	break;
	278	}
	279	mutex_unlock(&state->lock);
	280	if (ret)
	281	return ret;
	282
	283	*val = data[chan->address] / 100;
	284	val2 = (data[chan->address] % 100) 10000;
	285
	286	return IIO_VAL_INT_PLUS_MICRO;
	287	default:
	288	return -EINVAL;
	289	}
	290	case IIO_CHAN_INFO_SCALE:
	291	switch (chan->type) {
	292	case IIO_MASSCONCENTRATION:
	293	switch (chan->channel2) {
	294	case IIO_MOD_PM1:
	295	case IIO_MOD_PM2P5:
	296	case IIO_MOD_PM4:
	297	case IIO_MOD_PM10:
	298	*val = 0;
	299	*val2 = 10000;
	300
	301	return IIO_VAL_INT_PLUS_MICRO;
59b9bb0a JC	302	default:
59b9bb0a JC	303	return -EINVAL;
232e0f6d TD	304	}
	305	default:
	306	return -EINVAL;
	307	}
	308	}
	309
	310	return -EINVAL;
	311	}
	312
62129a08 TD	313	static int sps30_do_cmd_reset(struct sps30_state *state)
	314	{
	315	int ret;
	316
	317	ret = sps30_do_cmd(state, SPS30_RESET, NULL, 0);
	318	msleep(300);
	319	/*
	320	* Power-on-reset causes sensor to produce some glitch on i2c bus and
	321	* some controllers end up in error state. Recover simply by placing
	322	* some data on the bus, for example STOP_MEAS command, which
	323	* is NOP in this case.
	324	*/
	325	sps30_do_cmd(state, SPS30_STOP_MEAS, NULL, 0);
	326	state->state = RESET;
	327
	328	return ret;
	329	}
	330
c546d496 TD	331	static ssize_t start_cleaning_store(struct device *dev,
	332	struct device_attribute *attr,
	333	const char *buf, size_t len)
	334	{
	335	struct iio_dev *indio_dev = dev_to_iio_dev(dev);
	336	struct sps30_state *state = iio_priv(indio_dev);
	337	int val, ret;
	338
	339	if (kstrtoint(buf, 0, &val) \|\| val != 1)
	340	return -EINVAL;
	341
	342	mutex_lock(&state->lock);
	343	ret = sps30_do_cmd(state, SPS30_START_FAN_CLEANING, NULL, 0);
	344	mutex_unlock(&state->lock);
	345	if (ret)
	346	return ret;
	347
	348	return len;
	349	}
	350
62129a08 TD	351	static ssize_t cleaning_period_show(struct device *dev,
	352	struct device_attribute *attr,
	353	char *buf)
	354	{
	355	struct iio_dev *indio_dev = dev_to_iio_dev(dev);
	356	struct sps30_state *state = iio_priv(indio_dev);
	357	u8 tmp[4];
	358	int ret;
	359
	360	mutex_lock(&state->lock);
	361	ret = sps30_do_cmd(state, SPS30_READ_AUTO_CLEANING_PERIOD, tmp, 4);
	362	mutex_unlock(&state->lock);
	363	if (ret)
	364	return ret;
	365
	366	return sprintf(buf, "%d\n", get_unaligned_be32(tmp));
	367	}
	368
	369	static ssize_t cleaning_period_store(struct device *dev,
	370	struct device_attribute *attr,
	371	const char *buf, size_t len)
	372	{
	373	struct iio_dev *indio_dev = dev_to_iio_dev(dev);
	374	struct sps30_state *state = iio_priv(indio_dev);
	375	int val, ret;
	376	u8 tmp[4];
	377
	378	if (kstrtoint(buf, 0, &val))
	379	return -EINVAL;
	380
	381	if ((val < SPS30_AUTO_CLEANING_PERIOD_MIN) \|\|
	382	(val > SPS30_AUTO_CLEANING_PERIOD_MAX))
	383	return -EINVAL;
	384
	385	put_unaligned_be32(val, tmp);
	386
	387	mutex_lock(&state->lock);
	388	ret = sps30_do_cmd(state, SPS30_AUTO_CLEANING_PERIOD, tmp, 0);
	389	if (ret) {
	390	mutex_unlock(&state->lock);
	391	return ret;
	392	}
	393
	394	msleep(20);
	395
	396	/*
	397	* sensor requires reset in order to return up to date self cleaning
	398	* period
	399	*/
	400	ret = sps30_do_cmd_reset(state);
	401	if (ret)
	402	dev_warn(dev,
	403	"period changed but reads will return the old value\n");
	404
	405	mutex_unlock(&state->lock);
	406
	407	return len;
	408	}
	409
	410	static ssize_t cleaning_period_available_show(struct device *dev,
	411	struct device_attribute *attr,
	412	char *buf)
	413	{
	414	return snprintf(buf, PAGE_SIZE, "[%d %d %d]\n",
415	SPS30_AUTO_CLEANING_PERIOD_MIN, 1,
416	SPS30_AUTO_CLEANING_PERIOD_MAX);
417	}
418
c546d496	419	static IIO_DEVICE_ATTR_WO(start_cleaning, 0);
62129a08 TD	420	static IIO_DEVICE_ATTR_RW(cleaning_period, 0);
62129a08 TD	421	static IIO_DEVICE_ATTR_RO(cleaning_period_available, 0);
c546d496 TD	422
	423	static struct attribute *sps30_attrs[] = {
	424	&iio_dev_attr_start_cleaning.dev_attr.attr,
62129a08 TD	425	&iio_dev_attr_cleaning_period.dev_attr.attr,
62129a08 TD	426	&iio_dev_attr_cleaning_period_available.dev_attr.attr,
c546d496 TD	427	NULL
	428	};
	429
	430	static const struct attribute_group sps30_attr_group = {
	431	.attrs = sps30_attrs,
	432	};
	433
232e0f6d	434	static const struct iio_info sps30_info = {
c546d496	435	.attrs = &sps30_attr_group,
232e0f6d TD	436	.read_raw = sps30_read_raw,
	437	};
	438
	439	#define SPS30_CHAN(_index, _mod) { \
	440	.type = IIO_MASSCONCENTRATION, \
	441	.modified = 1, \
	442	.channel2 = IIO_MOD_ ## _mod, \
	443	.info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED), \
	444	.info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE), \
	445	.address = _mod, \
	446	.scan_index = _index, \
	447	.scan_type = { \
	448	.sign = 'u', \
	449	.realbits = 19, \
	450	.storagebits = 32, \
	451	.endianness = IIO_CPU, \
	452	}, \
	453	}
	454
	455	static const struct iio_chan_spec sps30_channels[] = {
	456	SPS30_CHAN(0, PM1),
	457	SPS30_CHAN(1, PM2P5),
	458	SPS30_CHAN(2, PM4),
	459	SPS30_CHAN(3, PM10),
	460	IIO_CHAN_SOFT_TIMESTAMP(4),
	461	};
	462
	463	static void sps30_stop_meas(void *data)
	464	{
	465	struct sps30_state *state = data;
	466
	467	sps30_do_cmd(state, SPS30_STOP_MEAS, NULL, 0);
	468	}
	469
	470	static const unsigned long sps30_scan_masks[] = { 0x0f, 0x00 };
	471
	472	static int sps30_probe(struct i2c_client *client)
	473	{
	474	struct iio_dev *indio_dev;
	475	struct sps30_state *state;
	476	u8 buf[32];
	477	int ret;
	478
	479	if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
	480	return -EOPNOTSUPP;
	481
	482	indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*state));
	483	if (!indio_dev)
	484	return -ENOMEM;
	485
	486	state = iio_priv(indio_dev);
	487	i2c_set_clientdata(client, indio_dev);
	488	state->client = client;
62129a08	489	state->state = RESET;
232e0f6d TD	490	indio_dev->info = &sps30_info;
	491	indio_dev->name = client->name;
	492	indio_dev->channels = sps30_channels;
	493	indio_dev->num_channels = ARRAY_SIZE(sps30_channels);
	494	indio_dev->modes = INDIO_DIRECT_MODE;
	495	indio_dev->available_scan_masks = sps30_scan_masks;
	496
	497	mutex_init(&state->lock);
	498	crc8_populate_msb(sps30_crc8_table, SPS30_CRC8_POLYNOMIAL);
	499
62129a08	500	ret = sps30_do_cmd_reset(state);
232e0f6d TD	501	if (ret) {
	502	dev_err(&client->dev, "failed to reset device\n");
	503	return ret;
	504	}
232e0f6d TD	505
	506	ret = sps30_do_cmd(state, SPS30_READ_SERIAL, buf, sizeof(buf));
	507	if (ret) {
	508	dev_err(&client->dev, "failed to read serial number\n");
	509	return ret;
	510	}
	511	/* returned serial number is already NUL terminated */
	512	dev_info(&client->dev, "serial number: %s\n", buf);
	513
232e0f6d TD	514	ret = devm_add_action_or_reset(&client->dev, sps30_stop_meas, state);
	515	if (ret)
	516	return ret;
	517
	518	ret = devm_iio_triggered_buffer_setup(&client->dev, indio_dev, NULL,
	519	sps30_trigger_handler, NULL);
	520	if (ret)
	521	return ret;
	522
	523	return devm_iio_device_register(&client->dev, indio_dev);
	524	}
	525
	526	static const struct i2c_device_id sps30_id[] = {
	527	{ "sps30" },
	528	{ }
	529	};
	530	MODULE_DEVICE_TABLE(i2c, sps30_id);
	531
	532	static const struct of_device_id sps30_of_match[] = {
	533	{ .compatible = "sensirion,sps30" },
	534	{ }
	535	};
	536	MODULE_DEVICE_TABLE(of, sps30_of_match);
	537
	538	static struct i2c_driver sps30_driver = {
	539	.driver = {
	540	.name = "sps30",
	541	.of_match_table = sps30_of_match,
	542	},
	543	.id_table = sps30_id,
	544	.probe_new = sps30_probe,
	545	};
	546	module_i2c_driver(sps30_driver);
	547
	548	MODULE_AUTHOR("Tomasz Duszynski <tduszyns@gmail.com>");
	549	MODULE_DESCRIPTION("Sensirion SPS30 particulate matter sensor driver");
	550	MODULE_LICENSE("GPL v2");