kernel: add kernel module for Sensirion SPS30 PMS

Adds into 4.19 backported kernel module from 5.1 for Sensirion SPS30
particulate matter sensor, for kernel 5.4 backported dependency fix.

Signed-off-by: Petr Štetiar <ynezz@true.cz>

11 files changed, 1211 insertions, 0 deletions

diff --git a/package/kernel/linux/modules/iio.mk b/package/kernel/linux/modules/iio.mk
index 430f318951..17ffdc3441 100644
--- a/package/kernel/linux/modules/iio.mk
+++ b/package/kernel/linux/modules/iio.mk
@@ -344,6 +344,22 @@ endef
 $(eval $(call KernelPackage,iio-st_sensors-i2c))
 
 
+define KernelPackage/iio-sps30
+  SUBMENU:=$(IIO_MENU)
+  DEPENDS:=@!LINUX_4_14 +kmod-i2c-core +kmod-iio-core +kmod-industrialio-triggered-buffer +kmod-lib-crc8
+  TITLE:=Sensirion SPS30 particulate matter sensor
+  KCONFIG:=CONFIG_SPS30
+  FILES:=$(LINUX_DIR)/drivers/iio/chemical/sps30.ko
+  AUTOLOAD:=$(call AutoProbe,sps30)
+endef
+
+define KernelPackage/iio-sps30/description
+ Support for the Sensirion SPS30 particulate matter sensor.
+endef
+
+$(eval $(call KernelPackage,iio-sps30))
+
+
 define KernelPackage/iio-st_sensors-spi
   SUBMENU:=$(IIO_MENU)
   TITLE:=STMicroelectronics accelerometer 3-Axis Driver (SPI)
diff --git a/target/linux/generic/backport-4.19/499-v4.22-iio-add-IIO_MASSCONCENTRATION-channel-type.patch b/target/linux/generic/backport-4.19/499-v4.22-iio-add-IIO_MASSCONCENTRATION-channel-type.patch
new file mode 100644
index 0000000000..c214495f03
--- /dev/null
+++ b/target/linux/generic/backport-4.19/499-v4.22-iio-add-IIO_MASSCONCENTRATION-channel-type.patch
@@ -0,0 +1,144 @@
+From 17abc9ec68b73ddeb262a507a62421016b9c54d5 Mon Sep 17 00:00:00 2001
+From: Tomasz Duszynski <tduszyns@gmail.com>
+Date: Fri, 14 Dec 2018 19:28:01 +0100
+Subject: [PATCH] iio: add IIO_MASSCONCENTRATION channel type
+
+Measuring particulate matter in ug / m3 (micro-grams per cubic meter)
+is de facto standard. Existing air quality sensors usually follow
+this convention and are capable of returning measurements using
+this unit.
+
+IIO currently does not offer suitable channel type for this
+type of measurements hence this patch adds this.
+
+In addition, extra modifiers are introduced used for distinguishing
+between fine pm1, pm2p5 and coarse pm4, pm10 particle measurements, i.e
+IIO_MOD_PM1, IIO_MOD_PM25 and IIO_MOD_PM4, IIO_MOD_PM10.
+
+pmX consists of particles with aerodynamic diameter less or equal to
+X micrometers.
+
+Signed-off-by: Tomasz Duszynski <tduszyns@gmail.com>
+Acked-by: Matt Ranostay <matt.ranostay@konsulko.com>
+Signed-off-by: Jonathan Cameron <Jonathan.Cameron@huawei.com>
+---
+ Documentation/ABI/testing/sysfs-bus-iio | 17 ++++++++++++++++-
+ drivers/iio/industrialio-core.c         |  5 +++++
+ include/uapi/linux/iio/types.h          |  5 +++++
+ tools/iio/iio_event_monitor.c           | 10 ++++++++++
+ 4 files changed, 36 insertions(+), 1 deletion(-)
+
+diff --git a/Documentation/ABI/testing/sysfs-bus-iio b/Documentation/ABI/testing/sysfs-bus-iio
+index 8127a08e366d..67fd88bf7910 100644
+--- a/Documentation/ABI/testing/sysfs-bus-iio
++++ b/Documentation/ABI/testing/sysfs-bus-iio
+@@ -1684,4 +1684,19 @@ KernelVersion:	4.18
+ Contact:	linux-iio@vger.kernel.org
+ Description:
+ 		Raw (unscaled) phase difference reading from channel Y
+-		that can be processed to radians.
+\ No newline at end of file
++		that can be processed to radians.
++
++What:		/sys/bus/iio/devices/iio:deviceX/in_massconcentration_pm1_input
++What:		/sys/bus/iio/devices/iio:deviceX/in_massconcentrationY_pm1_input
++What:		/sys/bus/iio/devices/iio:deviceX/in_massconcentration_pm2p5_input
++What:		/sys/bus/iio/devices/iio:deviceX/in_massconcentrationY_pm2p5_input
++What:		/sys/bus/iio/devices/iio:deviceX/in_massconcentration_pm4_input
++What:		/sys/bus/iio/devices/iio:deviceX/in_massconcentrationY_pm4_input
++What:		/sys/bus/iio/devices/iio:deviceX/in_massconcentration_pm10_input
++What:		/sys/bus/iio/devices/iio:deviceX/in_massconcentrationY_pm10_input
++KernelVersion:	4.22
++Contact:	linux-iio@vger.kernel.org
++Description:
++		Mass concentration reading of particulate matter in ug / m3.
++		pmX consists of particles with aerodynamic diameter less or
++		equal to X micrometers.
+diff --git a/drivers/iio/industrialio-core.c b/drivers/iio/industrialio-core.c
+index 4f5cd9f60870..4700fd5d8c90 100644
+--- a/drivers/iio/industrialio-core.c
++++ b/drivers/iio/industrialio-core.c
+@@ -87,6 +87,7 @@ static const char * const iio_chan_type_name_spec[] = {
+ 	[IIO_GRAVITY]  = "gravity",
+ 	[IIO_POSITIONRELATIVE]  = "positionrelative",
+ 	[IIO_PHASE] = "phase",
++	[IIO_MASSCONCENTRATION] = "massconcentration",
+ };
+ 
+ static const char * const iio_modifier_names[] = {
+@@ -127,6 +128,10 @@ static const char * const iio_modifier_names[] = {
+ 	[IIO_MOD_Q] = "q",
+ 	[IIO_MOD_CO2] = "co2",
+ 	[IIO_MOD_VOC] = "voc",
++	[IIO_MOD_PM1] = "pm1",
++	[IIO_MOD_PM2P5] = "pm2p5",
++	[IIO_MOD_PM4] = "pm4",
++	[IIO_MOD_PM10] = "pm10",
+ };
+ 
+ /* relies on pairs of these shared then separate */
+diff --git a/include/uapi/linux/iio/types.h b/include/uapi/linux/iio/types.h
+index 92baabc103ac..c59adac24b1c 100644
+--- a/include/uapi/linux/iio/types.h
++++ b/include/uapi/linux/iio/types.h
+@@ -46,6 +46,7 @@ enum iio_chan_type {
+ 	IIO_GRAVITY,
+ 	IIO_POSITIONRELATIVE,
+ 	IIO_PHASE,
++	IIO_MASSCONCENTRATION,
+ };
+ 
+ enum iio_modifier {
+@@ -87,6 +88,10 @@ enum iio_modifier {
+ 	IIO_MOD_VOC,
+ 	IIO_MOD_LIGHT_UV,
+ 	IIO_MOD_LIGHT_DUV,
++	IIO_MOD_PM1,
++	IIO_MOD_PM2P5,
++	IIO_MOD_PM4,
++	IIO_MOD_PM10,
+ };
+ 
+ enum iio_event_type {
+diff --git a/tools/iio/iio_event_monitor.c b/tools/iio/iio_event_monitor.c
+index ac2de6b7e89f..f6b8003fbe3c 100644
+--- a/tools/iio/iio_event_monitor.c
++++ b/tools/iio/iio_event_monitor.c
+@@ -60,6 +60,7 @@ static const char * const iio_chan_type_name_spec[] = {
+ 	[IIO_GRAVITY] = "gravity",
+ 	[IIO_POSITIONRELATIVE] = "positionrelative",
+ 	[IIO_PHASE] = "phase",
++	[IIO_MASSCONCENTRATION] = "massconcentration",
+ };
+ 
+ static const char * const iio_ev_type_text[] = {
+@@ -115,6 +116,10 @@ static const char * const iio_modifier_names[] = {
+ 	[IIO_MOD_Q] = "q",
+ 	[IIO_MOD_CO2] = "co2",
+ 	[IIO_MOD_VOC] = "voc",
++	[IIO_MOD_PM1] = "pm1",
++	[IIO_MOD_PM2P5] = "pm2p5",
++	[IIO_MOD_PM4] = "pm4",
++	[IIO_MOD_PM10] = "pm10",
+ };
+ 
+ static bool event_is_known(struct iio_event_data *event)
+@@ -156,6 +161,7 @@ static bool event_is_known(struct iio_event_data *event)
+ 	case IIO_GRAVITY:
+ 	case IIO_POSITIONRELATIVE:
+ 	case IIO_PHASE:
++	case IIO_MASSCONCENTRATION:
+ 		break;
+ 	default:
+ 		return false;
+@@ -200,6 +206,10 @@ static bool event_is_known(struct iio_event_data *event)
+ 	case IIO_MOD_Q:
+ 	case IIO_MOD_CO2:
+ 	case IIO_MOD_VOC:
++	case IIO_MOD_PM1:
++	case IIO_MOD_PM2P5:
++	case IIO_MOD_PM4:
++	case IIO_MOD_PM10:
+ 		break;
+ 	default:
+ 		return false;
diff --git a/target/linux/generic/backport-4.19/500-v5.1-iio-chemical-add-support-for-Sensirion-SPS30-sensor.patch b/target/linux/generic/backport-4.19/500-v5.1-iio-chemical-add-support-for-Sensirion-SPS30-sensor.patch
new file mode 100644
index 0000000000..73210b8e0e
--- /dev/null
+++ b/target/linux/generic/backport-4.19/500-v5.1-iio-chemical-add-support-for-Sensirion-SPS30-sensor.patch
@@ -0,0 +1,461 @@
+From 232e0f6ddeaee104d64675fe7d0cc142cf955f35 Mon Sep 17 00:00:00 2001
+From: Tomasz Duszynski <tduszyns@gmail.com>
+Date: Fri, 14 Dec 2018 19:28:02 +0100
+Subject: [PATCH] iio: chemical: add support for Sensirion SPS30 sensor
+
+Add support for Sensirion SPS30 particulate matter sensor.
+
+Signed-off-by: Tomasz Duszynski <tduszyns@gmail.com>
+Signed-off-by: Jonathan Cameron <Jonathan.Cameron@huawei.com>
+---
+ drivers/iio/chemical/Kconfig  |  11 +
+ drivers/iio/chemical/Makefile |   1 +
+ drivers/iio/chemical/sps30.c  | 407 ++++++++++++++++++++++++++++++++++
+ 3 files changed, 419 insertions(+)
+ create mode 100644 drivers/iio/chemical/sps30.c
+
+diff --git a/drivers/iio/chemical/Kconfig b/drivers/iio/chemical/Kconfig
+index b8e005be4f87..57832b4360e9 100644
+--- a/drivers/iio/chemical/Kconfig
++++ b/drivers/iio/chemical/Kconfig
+@@ -61,6 +61,17 @@ config IAQCORE
+ 	  iAQ-Core Continuous/Pulsed VOC (Volatile Organic Compounds)
+ 	  sensors
+ 
++config SPS30
++	tristate "SPS30 particulate matter sensor"
++	depends on I2C
++	select CRC8
++	help
++	  Say Y here to build support for the Sensirion SPS30 particulate
++	  matter sensor.
++
++	  To compile this driver as a module, choose M here: the module will
++	  be called sps30.
++
+ config VZ89X
+ 	tristate "SGX Sensortech MiCS VZ89X VOC sensor"
+ 	depends on I2C
+diff --git a/drivers/iio/chemical/Makefile b/drivers/iio/chemical/Makefile
+index 2f4c4ba4d781..9f42f4252151 100644
+--- a/drivers/iio/chemical/Makefile
++++ b/drivers/iio/chemical/Makefile
+@@ -9,4 +9,5 @@ obj-$(CONFIG_BME680_I2C) += bme680_i2c.o
+ obj-$(CONFIG_BME680_SPI) += bme680_spi.o
+ obj-$(CONFIG_CCS811)		+= ccs811.o
+ obj-$(CONFIG_IAQCORE)		+= ams-iaq-core.o
++obj-$(CONFIG_SPS30) += sps30.o
+ obj-$(CONFIG_VZ89X)		+= vz89x.o
+diff --git a/drivers/iio/chemical/sps30.c b/drivers/iio/chemical/sps30.c
+new file mode 100644
+index 000000000000..fa3cd409b90b
+--- /dev/null
++++ b/drivers/iio/chemical/sps30.c
+@@ -0,0 +1,407 @@
++// SPDX-License-Identifier: GPL-2.0
++/*
++ * Sensirion SPS30 particulate matter sensor driver
++ *
++ * Copyright (c) Tomasz Duszynski <tduszyns@gmail.com>
++ *
++ * I2C slave address: 0x69
++ *
++ * TODO:
++ *  - support for turning on fan cleaning
++ *  - support for reading/setting auto cleaning interval
++ */
++
++#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
++
++#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/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
++
++/* 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
++
++enum {
++	PM1,
++	PM2P5,
++	PM4,
++	PM10,
++};
++
++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;
++};
++
++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:
++		ret = sps30_write_then_read(state, buf, 2, NULL, 0);
++		break;
++	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;
++	}
++
++	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];
++
++	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)
++		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;
++	s32 data[4 + 2]; /* PM1, PM2P5, PM4, PM10, timestamp */
++
++	mutex_lock(&state->lock);
++	ret = sps30_do_meas(state, data, 4);
++	mutex_unlock(&state->lock);
++	if (ret)
++		goto err;
++
++	iio_push_to_buffers_with_timestamp(indio_dev, data,
++					   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;
++		}
++	}
++
++	return -EINVAL;
++}
++
++static const struct iio_info sps30_info = {
++	.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;
++	indio_dev->dev.parent = &client->dev;
++	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(state, SPS30_RESET, NULL, 0);
++	if (ret) {
++		dev_err(&client->dev, "failed to reset device\n");
++		return ret;
++	}
++	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);
++
++	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 = sps30_do_cmd(state, SPS30_START_MEAS, NULL, 0);
++	if (ret) {
++		dev_err(&client->dev, "failed to start measurement\n");
++		return ret;
++	}
++
++	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");
diff --git a/target/linux/generic/backport-4.19/501-v5.1-iio-chemical-sps30-add-support-for-self-cleaning.patch b/target/linux/generic/backport-4.19/501-v5.1-iio-chemical-sps30-add-support-for-self-cleaning.patch
new file mode 100644
index 0000000000..9e4b9c2d43
--- /dev/null
+++ b/target/linux/generic/backport-4.19/501-v5.1-iio-chemical-sps30-add-support-for-self-cleaning.patch
@@ -0,0 +1,105 @@
+From c546d49656143855093c7b7fde60866e6e23a69d Mon Sep 17 00:00:00 2001
+From: Tomasz Duszynski <tduszyns@gmail.com>
+Date: Tue, 18 Dec 2018 21:28:09 +0100
+Subject: [PATCH] iio: chemical: sps30: add support for self cleaning
+
+Self cleaning is especially useful in cases where sensor undergoes
+frequent power on/off cycles. In such scenarios it is recommended to
+turn self cleaning at least once per week in order to maintain reliable
+measurements.
+
+Self cleaning is activated by writing 1 to a dedicated attribute.
+Internal fan accelerates to its maximum speed and keeps spinning
+for about 10 seconds blowing out accumulated dust.
+
+Signed-off-by: Tomasz Duszynski <tduszyns@gmail.com>
+Tested-by: Andreas Brauchli <andreas.brauchli@sensirion.com>
+Signed-off-by: Jonathan Cameron <Jonathan.Cameron@huawei.com>
+---
+ Documentation/ABI/testing/sysfs-bus-iio-sps30 |  8 +++++
+ drivers/iio/chemical/sps30.c                  | 35 ++++++++++++++++++-
+ 2 files changed, 42 insertions(+), 1 deletion(-)
+ create mode 100644 Documentation/ABI/testing/sysfs-bus-iio-sps30
+
+diff --git a/Documentation/ABI/testing/sysfs-bus-iio-sps30 b/Documentation/ABI/testing/sysfs-bus-iio-sps30
+new file mode 100644
+index 000000000000..e7ce2c57635e
+--- /dev/null
++++ b/Documentation/ABI/testing/sysfs-bus-iio-sps30
+@@ -0,0 +1,8 @@
++What:		/sys/bus/iio/devices/iio:deviceX/start_cleaning
++Date:		December 2018
++KernelVersion:	4.22
++Contact:	linux-iio@vger.kernel.org
++Description:
++		Writing 1 starts sensor self cleaning. Internal fan accelerates
++		to its maximum speed and keeps spinning for about 10 seconds in
++		order to blow out accumulated dust.
+diff --git a/drivers/iio/chemical/sps30.c b/drivers/iio/chemical/sps30.c
+index fa3cd409b90b..f3b4390c8f5c 100644
+--- a/drivers/iio/chemical/sps30.c
++++ b/drivers/iio/chemical/sps30.c
+@@ -7,7 +7,6 @@
+  * I2C slave address: 0x69
+  *
+  * TODO:
+- *  - support for turning on fan cleaning
+  *  - support for reading/setting auto cleaning interval
+  */
+ 
+@@ -37,6 +36,7 @@
+ #define SPS30_READ_DATA_READY_FLAG 0x0202
+ #define SPS30_READ_DATA 0x0300
+ #define SPS30_READ_SERIAL 0xd033
++#define SPS30_START_FAN_CLEANING 0x5607
+ 
+ enum {
+ 	PM1,
+@@ -104,6 +104,7 @@ static int sps30_do_cmd(struct sps30_state *state, u16 cmd, u8 *data, int size)
+ 		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_DATA_READY_FLAG:
+@@ -275,7 +276,39 @@ static int sps30_read_raw(struct iio_dev *indio_dev,
+ 	return -EINVAL;
+ }
+ 
++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 IIO_DEVICE_ATTR_WO(start_cleaning, 0);
++
++static struct attribute *sps30_attrs[] = {
++	&iio_dev_attr_start_cleaning.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,
+ };
+ 
diff --git a/target/linux/generic/backport-4.19/502-v5.1-iio-chemical-sps30-allow-changing-self-cleaning-peri.patch b/target/linux/generic/backport-4.19/502-v5.1-iio-chemical-sps30-allow-changing-self-cleaning-peri.patch
new file mode 100644
index 0000000000..ca3e23b8fc
--- /dev/null
+++ b/target/linux/generic/backport-4.19/502-v5.1-iio-chemical-sps30-allow-changing-self-cleaning-peri.patch
@@ -0,0 +1,297 @@
+From 62129a0849d27cc94ced832bcf9dcde283dcbe08 Mon Sep 17 00:00:00 2001
+From: Tomasz Duszynski <tduszyns@gmail.com>
+Date: Tue, 15 Jan 2019 20:00:06 +0100
+Subject: [PATCH] iio: chemical: sps30: allow changing self cleaning period
+
+Sensor can periodically trigger self cleaning. Period can be changed by
+writing a new value to a dedicated attribute. Upon attribute read
+current period gets returned.
+
+Signed-off-by: Tomasz Duszynski <tduszyns@gmail.com>
+Signed-off-by: Jonathan Cameron <Jonathan.Cameron@huawei.com>
+---
+ Documentation/ABI/testing/sysfs-bus-iio-sps30 |  20 +++
+ drivers/iio/chemical/sps30.c                  | 143 +++++++++++++++---
+ 2 files changed, 145 insertions(+), 18 deletions(-)
+
+diff --git a/Documentation/ABI/testing/sysfs-bus-iio-sps30 b/Documentation/ABI/testing/sysfs-bus-iio-sps30
+index e7ce2c57635e..143df8e89d08 100644
+--- a/Documentation/ABI/testing/sysfs-bus-iio-sps30
++++ b/Documentation/ABI/testing/sysfs-bus-iio-sps30
+@@ -6,3 +6,23 @@ Description:
+ 		Writing 1 starts sensor self cleaning. Internal fan accelerates
+ 		to its maximum speed and keeps spinning for about 10 seconds in
+ 		order to blow out accumulated dust.
++
++What:		/sys/bus/iio/devices/iio:deviceX/cleaning_period
++Date:		January 2019
++KernelVersion:	5.1
++Contact:	linux-iio@vger.kernel.org
++Description:
++		Sensor is capable of triggering self cleaning periodically.
++		Period can be changed by writing a new value here. Upon reading
++		the current one is returned. Units are seconds.
++
++		Writing 0 disables periodical self cleaning entirely.
++
++What:		/sys/bus/iio/devices/iio:deviceX/cleaning_period_available
++Date:		January 2019
++KernelVersion:	5.1
++Contact:	linux-iio@vger.kernel.org
++Description:
++		The range of available values in seconds represented as the
++		minimum value, the step and the maximum value, all enclosed in
++		square brackets.
+diff --git a/drivers/iio/chemical/sps30.c b/drivers/iio/chemical/sps30.c
+index f3b4390c8f5c..376fac41ecb5 100644
+--- a/drivers/iio/chemical/sps30.c
++++ b/drivers/iio/chemical/sps30.c
+@@ -5,9 +5,6 @@
+  * Copyright (c) Tomasz Duszynski <tduszyns@gmail.com>
+  *
+  * I2C slave address: 0x69
+- *
+- * TODO:
+- *  - support for reading/setting auto cleaning interval
+  */
+ 
+ #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+@@ -21,6 +18,7 @@
+ #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
+@@ -28,6 +26,9 @@
+ #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
+@@ -37,6 +38,9 @@
+ #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,
+@@ -45,6 +49,11 @@ enum {
+ 	PM10,
+ };
+ 
++enum {
++	RESET,
++	MEASURING,
++};
++
+ struct sps30_state {
+ 	struct i2c_client *client;
+ 	/*
+@@ -52,6 +61,7 @@ struct sps30_state {
+ 	 * Must be held whenever sequence of commands is to be executed.
+ 	 */
+ 	struct mutex lock;
++	int state;
+ };
+ 
+ DECLARE_CRC8_TABLE(sps30_crc8_table);
+@@ -107,6 +117,9 @@ static int sps30_do_cmd(struct sps30_state *state, u16 cmd, u8 *data, int size)
+ 	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;
+ 	case SPS30_READ_DATA_READY_FLAG:
+ 	case SPS30_READ_DATA:
+ 	case SPS30_READ_SERIAL:
+@@ -114,6 +127,15 @@ static int sps30_do_cmd(struct sps30_state *state, u16 cmd, u8 *data, int size)
+ 		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)
+@@ -170,6 +192,14 @@ 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)
+@@ -276,6 +306,24 @@ static int sps30_read_raw(struct iio_dev *indio_dev,
+ 	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)
+@@ -296,10 +344,82 @@ static ssize_t start_cleaning_store(struct device *dev,
+ 	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
+ };
+ 
+@@ -362,6 +482,7 @@ static int sps30_probe(struct i2c_client *client)
+ 	state = iio_priv(indio_dev);
+ 	i2c_set_clientdata(client, indio_dev);
+ 	state->client = client;
++	state->state = RESET;
+ 	indio_dev->dev.parent = &client->dev;
+ 	indio_dev->info = &sps30_info;
+ 	indio_dev->name = client->name;
+@@ -373,19 +494,11 @@ static int sps30_probe(struct i2c_client *client)
+ 	mutex_init(&state->lock);
+ 	crc8_populate_msb(sps30_crc8_table, SPS30_CRC8_POLYNOMIAL);
+ 
+-	ret = sps30_do_cmd(state, SPS30_RESET, NULL, 0);
++	ret = sps30_do_cmd_reset(state);
+ 	if (ret) {
+ 		dev_err(&client->dev, "failed to reset device\n");
+ 		return ret;
+ 	}
+-	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);
+ 
+ 	ret = sps30_do_cmd(state, SPS30_READ_SERIAL, buf, sizeof(buf));
+ 	if (ret) {
+@@ -395,12 +508,6 @@ static int sps30_probe(struct i2c_client *client)
+ 	/* returned serial number is already NUL terminated */
+ 	dev_info(&client->dev, "serial number: %s\n", buf);
+ 
+-	ret = sps30_do_cmd(state, SPS30_START_MEAS, NULL, 0);
+-	if (ret) {
+-		dev_err(&client->dev, "failed to start measurement\n");
+-		return ret;
+-	}
+-
+ 	ret = devm_add_action_or_reset(&client->dev, sps30_stop_meas, state);
+ 	if (ret)
+ 		return ret;
diff --git a/target/linux/generic/backport-4.19/503-v5.1-iio-chemical-sps30-remove-printk-format-specifier.patch b/target/linux/generic/backport-4.19/503-v5.1-iio-chemical-sps30-remove-printk-format-specifier.patch
new file mode 100644
index 0000000000..8cdd0a718d
--- /dev/null
+++ b/target/linux/generic/backport-4.19/503-v5.1-iio-chemical-sps30-remove-printk-format-specifier.patch
@@ -0,0 +1,27 @@
+From 3fa30bf7004bb8069826ef85487f4753666a73da Mon Sep 17 00:00:00 2001
+From: Tomasz Duszynski <tduszyns@gmail.com>
+Date: Sat, 2 Feb 2019 10:00:03 +0100
+Subject: [PATCH] iio: chemical: sps30: remove printk format specifier
+
+pr_fmt is used by printk wrappers. There are not any in the driver
+code so remove the format specifier.
+
+Signed-off-by: Tomasz Duszynski <tduszyns@gmail.com>
+Signed-off-by: Jonathan Cameron <Jonathan.Cameron@huawei.com>
+---
+ drivers/iio/chemical/sps30.c | 2 --
+ 1 file changed, 2 deletions(-)
+
+diff --git a/drivers/iio/chemical/sps30.c b/drivers/iio/chemical/sps30.c
+index 376fac41ecb5..e03a28a67146 100644
+--- a/drivers/iio/chemical/sps30.c
++++ b/drivers/iio/chemical/sps30.c
+@@ -7,8 +7,6 @@
+  * I2C slave address: 0x69
+  */
+ 
+-#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+-
+ #include <asm/unaligned.h>
+ #include <linux/crc8.h>
+ #include <linux/delay.h>
diff --git a/target/linux/generic/backport-4.19/504-v5.1-iio-chemical-sps30-fix-a-loop-timeout-test.patch b/target/linux/generic/backport-4.19/504-v5.1-iio-chemical-sps30-fix-a-loop-timeout-test.patch
new file mode 100644
index 0000000000..e0fcdc2ce2
--- /dev/null
+++ b/target/linux/generic/backport-4.19/504-v5.1-iio-chemical-sps30-fix-a-loop-timeout-test.patch
@@ -0,0 +1,28 @@
+From 905889b4a34c753a538015f0b2cdaa0c9e3a4fd5 Mon Sep 17 00:00:00 2001
+From: Dan Carpenter <dan.carpenter@oracle.com>
+Date: Sat, 9 Feb 2019 12:03:52 +0300
+Subject: [PATCH] iio: chemical: sps30: fix a loop timeout test
+
+The "while (tries--) {" loop is a postop so it exits with "tries" set
+to -1.
+
+Fixes: 232e0f6ddeae ("iio: chemical: add support for Sensirion SPS30 sensor")
+Signed-off-by: Dan Carpenter <dan.carpenter@oracle.com>
+Signed-off-by: Jonathan Cameron <Jonathan.Cameron@huawei.com>
+---
+ drivers/iio/chemical/sps30.c | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+diff --git a/drivers/iio/chemical/sps30.c b/drivers/iio/chemical/sps30.c
+index e03a28a67146..375df5060ed5 100644
+--- a/drivers/iio/chemical/sps30.c
++++ b/drivers/iio/chemical/sps30.c
+@@ -210,7 +210,7 @@ static int sps30_do_meas(struct sps30_state *state, s32 *data, int size)
+ 		msleep_interruptible(300);
+ 	}
+ 
+-	if (!tries)
++	if (tries == -1)
+ 		return -ETIMEDOUT;
+ 
+ 	ret = sps30_do_cmd(state, SPS30_READ_DATA, tmp, sizeof(int) * size);
diff --git a/target/linux/generic/backport-4.19/505-v5.1-iio-chemical-sps30-Supress-some-switch-fallthrough-w.patch b/target/linux/generic/backport-4.19/505-v5.1-iio-chemical-sps30-Supress-some-switch-fallthrough-w.patch
new file mode 100644
index 0000000000..a1c0b3ddca
--- /dev/null
+++ b/target/linux/generic/backport-4.19/505-v5.1-iio-chemical-sps30-Supress-some-switch-fallthrough-w.patch
@@ -0,0 +1,36 @@
+From 59b9bb0abca9efe47207301dbaf0d1beee2bd0f7 Mon Sep 17 00:00:00 2001
+From: Jonathan Cameron <Jonathan.Cameron@huawei.com>
+Date: Sat, 9 Feb 2019 19:32:58 +0000
+Subject: [PATCH] iio:chemical:sps30 Supress some switch fallthrough warnings.
+
+Fixes warnings reported on linux-next but marking one path
+and adding an explicit return in the other.
+
+Signed-off-by: Jonathan Cameron <Jonathan.Cameron@huawei.com>
+Cc: Andreas Brauchli <a.brauchli@elementarea.net>
+Acked-by: Tomasz Duszynski <tduszyns@gmail.com>
+---
+ drivers/iio/chemical/sps30.c | 3 +++
+ 1 file changed, 3 insertions(+)
+
+diff --git a/drivers/iio/chemical/sps30.c b/drivers/iio/chemical/sps30.c
+index 375df5060ed5..edbb956e81e8 100644
+--- a/drivers/iio/chemical/sps30.c
++++ b/drivers/iio/chemical/sps30.c
+@@ -118,6 +118,7 @@ static int sps30_do_cmd(struct sps30_state *state, u16 cmd, u8 *data, int size)
+ 	case SPS30_READ_AUTO_CLEANING_PERIOD:
+ 		buf[0] = SPS30_AUTO_CLEANING_PERIOD >> 8;
+ 		buf[1] = (u8)SPS30_AUTO_CLEANING_PERIOD;
++		/* fall through */
+ 	case SPS30_READ_DATA_READY_FLAG:
+ 	case SPS30_READ_DATA:
+ 	case SPS30_READ_SERIAL:
+@@ -295,6 +296,8 @@ static int sps30_read_raw(struct iio_dev *indio_dev,
+ 				*val2 = 10000;
+ 
+ 				return IIO_VAL_INT_PLUS_MICRO;
++			default:
++				return -EINVAL;
+ 			}
+ 		default:
+ 			return -EINVAL;
diff --git a/target/linux/generic/backport-4.19/506-v5.1-iio-chemical-sps30-Explicity-truncate-constant-by-ma.patch b/target/linux/generic/backport-4.19/506-v5.1-iio-chemical-sps30-Explicity-truncate-constant-by-ma.patch
new file mode 100644
index 0000000000..6b31483070
--- /dev/null
+++ b/target/linux/generic/backport-4.19/506-v5.1-iio-chemical-sps30-Explicity-truncate-constant-by-ma.patch
@@ -0,0 +1,33 @@
+From 78b75ab3f8c9dfac563b81105a1b838ec37a940e Mon Sep 17 00:00:00 2001
+From: Jonathan Cameron <Jonathan.Cameron@huawei.com>
+Date: Sun, 13 Oct 2019 10:55:15 +0100
+Subject: [PATCH] iio: chemical: sps30: Explicity truncate constant by masking
+
+When breaking up a constant to write to two 8 bit registers
+it isn't obvious to sparse that it was intentional.
+
+CHECK   drivers/iio/chemical/sps30.c
+drivers/iio/chemical/sps30.c:120:30: warning: cast truncates bits from constant value (8004 becomes 4)
+
+So in the interests of minimising noisy warnings, let us add
+a mask.
+
+Signed-off-by: Jonathan Cameron <Jonathan.Cameron@huawei.com>
+Acked-by: Tomasz Duszynski <tduszyns@gmail.com>
+---
+ drivers/iio/chemical/sps30.c | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+diff --git a/drivers/iio/chemical/sps30.c b/drivers/iio/chemical/sps30.c
+index edbb956e81e8..acb9f8ecbb3d 100644
+--- a/drivers/iio/chemical/sps30.c
++++ b/drivers/iio/chemical/sps30.c
+@@ -117,7 +117,7 @@ static int sps30_do_cmd(struct sps30_state *state, u16 cmd, u8 *data, int size)
+ 		break;
+ 	case SPS30_READ_AUTO_CLEANING_PERIOD:
+ 		buf[0] = SPS30_AUTO_CLEANING_PERIOD >> 8;
+-		buf[1] = (u8)SPS30_AUTO_CLEANING_PERIOD;
++		buf[1] = (u8)(SPS30_AUTO_CLEANING_PERIOD & 0xff);
+ 		/* fall through */
+ 	case SPS30_READ_DATA_READY_FLAG:
+ 	case SPS30_READ_DATA:
diff --git a/target/linux/generic/backport-4.19/507-v5.6-iio-chemical-sps30-fix-missing-triggered-buffer-depe.patch b/target/linux/generic/backport-4.19/507-v5.6-iio-chemical-sps30-fix-missing-triggered-buffer-depe.patch
new file mode 100644
index 0000000000..a2b274f75e
--- /dev/null
+++ b/target/linux/generic/backport-4.19/507-v5.6-iio-chemical-sps30-fix-missing-triggered-buffer-depe.patch
@@ -0,0 +1,32 @@
+From 61338e27e2eef3bfcd3df5c39cec5b9dc10ba25c Mon Sep 17 00:00:00 2001
+From: =?UTF-8?q?Petr=20=C5=A0tetiar?= <ynezz@true.cz>
+Date: Sun, 23 Feb 2020 22:08:25 +0100
+Subject: [PATCH] iio: chemical: sps30: fix missing triggered buffer dependency
+MIME-Version: 1.0
+Content-Type: text/plain; charset=UTF-8
+Content-Transfer-Encoding: 8bit
+
+SPS30 uses triggered buffer, but the dependency is not specified in the
+Kconfig file.  Fix this by selecting IIO_BUFFER and IIO_TRIGGERED_BUFFER
+config symbols.
+
+Cc: stable@vger.kernel.org
+Fixes: 232e0f6ddeae ("iio: chemical: add support for Sensirion SPS30 sensor")
+Signed-off-by: Petr Štetiar <ynezz@true.cz>
+---
+ drivers/iio/chemical/Kconfig | 2 ++
+ 1 file changed, 2 insertions(+)
+
+diff --git a/drivers/iio/chemical/Kconfig b/drivers/iio/chemical/Kconfig
+index 0b91de4df8f4..a7e65a59bf42 100644
+--- a/drivers/iio/chemical/Kconfig
++++ b/drivers/iio/chemical/Kconfig
+@@ -91,6 +91,8 @@ config SPS30
+ 	tristate "SPS30 particulate matter sensor"
+ 	depends on I2C
+ 	select CRC8
++	select IIO_BUFFER
++	select IIO_TRIGGERED_BUFFER
+ 	help
+ 	  Say Y here to build support for the Sensirion SPS30 particulate
+ 	  matter sensor.
diff --git a/target/linux/generic/backport-5.4/507-v5.6-iio-chemical-sps30-fix-missing-triggered-buffer-depe.patch b/target/linux/generic/backport-5.4/507-v5.6-iio-chemical-sps30-fix-missing-triggered-buffer-depe.patch
new file mode 100644
index 0000000000..a2b274f75e
--- /dev/null
+++ b/target/linux/generic/backport-5.4/507-v5.6-iio-chemical-sps30-fix-missing-triggered-buffer-depe.patch
@@ -0,0 +1,32 @@
+From 61338e27e2eef3bfcd3df5c39cec5b9dc10ba25c Mon Sep 17 00:00:00 2001
+From: =?UTF-8?q?Petr=20=C5=A0tetiar?= <ynezz@true.cz>
+Date: Sun, 23 Feb 2020 22:08:25 +0100
+Subject: [PATCH] iio: chemical: sps30: fix missing triggered buffer dependency
+MIME-Version: 1.0
+Content-Type: text/plain; charset=UTF-8
+Content-Transfer-Encoding: 8bit
+
+SPS30 uses triggered buffer, but the dependency is not specified in the
+Kconfig file.  Fix this by selecting IIO_BUFFER and IIO_TRIGGERED_BUFFER
+config symbols.
+
+Cc: stable@vger.kernel.org
+Fixes: 232e0f6ddeae ("iio: chemical: add support for Sensirion SPS30 sensor")
+Signed-off-by: Petr Štetiar <ynezz@true.cz>
+---
+ drivers/iio/chemical/Kconfig | 2 ++
+ 1 file changed, 2 insertions(+)
+
+diff --git a/drivers/iio/chemical/Kconfig b/drivers/iio/chemical/Kconfig
+index 0b91de4df8f4..a7e65a59bf42 100644
+--- a/drivers/iio/chemical/Kconfig
++++ b/drivers/iio/chemical/Kconfig
+@@ -91,6 +91,8 @@ config SPS30
+ 	tristate "SPS30 particulate matter sensor"
+ 	depends on I2C
+ 	select CRC8
++	select IIO_BUFFER
++	select IIO_TRIGGERED_BUFFER
+ 	help
+ 	  Say Y here to build support for the Sensirion SPS30 particulate
+ 	  matter sensor.