From: Petr Štetiar Date: Sun, 23 Feb 2020 21:50:22 +0000 (+0100) Subject: kernel: add kernel module for Sensirion SPS30 PMS X-Git-Url: http://git.lede-project.org./?a=commitdiff_plain;h=a9adb603d63904971984bf51be6d4724a8c76aa2;p=openwrt%2Fstaging%2Fynezz.git kernel: add kernel module for Sensirion SPS30 PMS Adds into 4.19 backported kernel module from 5.1 for Sensirion SPS30 particulate matter sensor. Signed-off-by: Petr Štetiar --- diff --git a/package/kernel/linux/modules/iio.mk b/package/kernel/linux/modules/iio.mk index 7ba21035ea..5e7808a18f 100644 --- a/package/kernel/linux/modules/iio.mk +++ b/package/kernel/linux/modules/iio.mk @@ -306,6 +306,22 @@ endef $(eval $(call KernelPackage,iio-si7020)) +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-tsl4531 SUBMENU:=$(IIO_MENU) DEPENDS:=+kmod-i2c-core +kmod-iio-core 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 +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 +Acked-by: Matt Ranostay +Signed-off-by: Jonathan Cameron +--- + 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 +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 +Signed-off-by: Jonathan Cameron +--- + 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 ++ * ++ * 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 ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++ ++#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 "); ++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 +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 +Tested-by: Andreas Brauchli +Signed-off-by: Jonathan Cameron +--- + 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 +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 +Signed-off-by: Jonathan Cameron +--- + 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 + * + * I2C slave address: 0x69 +- * +- * TODO: +- * - support for reading/setting auto cleaning interval + */ + + #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt +@@ -21,6 +18,7 @@ + #include + #include + #include ++#include + #include + + #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 +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 +Signed-off-by: Jonathan Cameron +--- + 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 + #include + #include 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 +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 +Signed-off-by: Jonathan Cameron +--- + 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 +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 +Cc: Andreas Brauchli +Acked-by: Tomasz Duszynski +--- + 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 +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 +Acked-by: Tomasz Duszynski +--- + 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?= +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 +--- + 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.