kernel: add kernel module for Sensirion SPS30 PMS wip/sensirion-sps30
authorPetr Štetiar <ynezz@true.cz>
Sun, 23 Feb 2020 21:50:22 +0000 (22:50 +0100)
committerPetr Štetiar <ynezz@true.cz>
Wed, 26 Feb 2020 10:00:32 +0000 (11:00 +0100)
Adds into 4.19 backported kernel module from 5.1 for Sensirion SPS30
particulate matter sensor.

Signed-off-by: Petr Štetiar <ynezz@true.cz>
package/kernel/linux/modules/iio.mk
target/linux/generic/backport-4.19/499-v4.22-iio-add-IIO_MASSCONCENTRATION-channel-type.patch [new file with mode: 0644]
target/linux/generic/backport-4.19/500-v5.1-iio-chemical-add-support-for-Sensirion-SPS30-sensor.patch [new file with mode: 0644]
target/linux/generic/backport-4.19/501-v5.1-iio-chemical-sps30-add-support-for-self-cleaning.patch [new file with mode: 0644]
target/linux/generic/backport-4.19/502-v5.1-iio-chemical-sps30-allow-changing-self-cleaning-peri.patch [new file with mode: 0644]
target/linux/generic/backport-4.19/503-v5.1-iio-chemical-sps30-remove-printk-format-specifier.patch [new file with mode: 0644]
target/linux/generic/backport-4.19/504-v5.1-iio-chemical-sps30-fix-a-loop-timeout-test.patch [new file with mode: 0644]
target/linux/generic/backport-4.19/505-v5.1-iio-chemical-sps30-Supress-some-switch-fallthrough-w.patch [new file with mode: 0644]
target/linux/generic/backport-4.19/506-v5.1-iio-chemical-sps30-Explicity-truncate-constant-by-ma.patch [new file with mode: 0644]
target/linux/generic/backport-4.19/507-v5.6-iio-chemical-sps30-fix-missing-triggered-buffer-depe.patch [new file with mode: 0644]

index 7ba21035ea747db1f9ff3cd2d37914a5c9d21f51..5e7808a18ffa234a539721a23302d24fccf8a099 100644 (file)
@@ -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 (file)
index 0000000..c214495
--- /dev/null
@@ -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 (file)
index 0000000..73210b8
--- /dev/null
@@ -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 (file)
index 0000000..9e4b9c2
--- /dev/null
@@ -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 (file)
index 0000000..ca3e23b
--- /dev/null
@@ -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 (file)
index 0000000..8cdd0a7
--- /dev/null
@@ -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 (file)
index 0000000..e0fcdc2
--- /dev/null
@@ -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 (file)
index 0000000..a1c0b3d
--- /dev/null
@@ -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 (file)
index 0000000..6b31483
--- /dev/null
@@ -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 (file)
index 0000000..a2b274f
--- /dev/null
@@ -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.