iio: chemical: sgp30: Support Sensirion SGP30/SGPC3 sensors
authorAndreas Brauchli <a.brauchli@elementarea.net>
Thu, 13 Dec 2018 14:43:23 +0000 (15:43 +0100)
committerJonathan Cameron <Jonathan.Cameron@huawei.com>
Sun, 16 Dec 2018 14:05:58 +0000 (14:05 +0000)
Support Sensirion SGP30 and SGPC3 multi-pixel I2C gas sensors

Supported Features:

* Indoor Air Quality (IAQ) concentrations for
  - tVOC (in_concentration_voc_input)
  - CO2eq (in_concentration_co2_input) - SGP30 only

  IAQ concentrations are periodically read out by a background thread
  to allow the sensor to maintain its internal baseline.

* Gas concentration signals
  - Ethanol (in_concentration_ethanol_raw)
  - H2 (in_concentration_h2_raw) - SGP30 only

https://www.sensirion.com/file/datasheet_sgp30
https://www.sensirion.com/file/datasheet_sgpc3

Signed-off-by: Andreas Brauchli <andreas.brauchli@sensirion.com>
Signed-off-by: Jonathan Cameron <Jonathan.Cameron@huawei.com>
drivers/iio/chemical/Makefile
drivers/iio/chemical/sgp30.c [new file with mode: 0644]

index 9f42f42521514285a8fa3a6d466ce6465742914f..65bf0f89c0e4464c49383a98c0a30a7edb6a640a 100644 (file)
@@ -9,5 +9,6 @@ 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_SENSIRION_SGP30)  += sgp30.o
 obj-$(CONFIG_SPS30) += sps30.o
 obj-$(CONFIG_VZ89X)            += vz89x.o
diff --git a/drivers/iio/chemical/sgp30.c b/drivers/iio/chemical/sgp30.c
new file mode 100644 (file)
index 0000000..8cc8fe5
--- /dev/null
@@ -0,0 +1,591 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * sgp30.c - Support for Sensirion SGP Gas Sensors
+ *
+ * Copyright (C) 2018 Andreas Brauchli <andreas.brauchli@sensirion.com>
+ *
+ * I2C slave address: 0x58
+ *
+ * Datasheets:
+ * https://www.sensirion.com/file/datasheet_sgp30
+ * https://www.sensirion.com/file/datasheet_sgpc3
+ *
+ * TODO:
+ * - baseline support
+ * - humidity compensation
+ * - power mode switching (SGPC3)
+ */
+
+#include <linux/crc8.h>
+#include <linux/delay.h>
+#include <linux/kthread.h>
+#include <linux/module.h>
+#include <linux/mutex.h>
+#include <linux/i2c.h>
+#include <linux/of_device.h>
+#include <linux/iio/iio.h>
+#include <linux/iio/sysfs.h>
+
+#define SGP_WORD_LEN                           2
+#define SGP_CRC8_POLYNOMIAL                    0x31
+#define SGP_CRC8_INIT                          0xff
+#define SGP_CRC8_LEN                           1
+#define SGP_CMD(cmd_word)                      cpu_to_be16(cmd_word)
+#define SGP_CMD_DURATION_US                    12000
+#define SGP_MEASUREMENT_DURATION_US            50000
+#define SGP_CMD_LEN                            SGP_WORD_LEN
+#define SGP_CMD_MAX_BUF_SIZE                   (SGP_CMD_LEN + 2 * SGP_WORD_LEN)
+#define SGP_MEASUREMENT_LEN                    2
+#define SGP30_MEASURE_INTERVAL_HZ              1
+#define SGPC3_MEASURE_INTERVAL_HZ              2
+#define SGP_VERS_PRODUCT(data) ((((data)->feature_set) & 0xf000) >> 12)
+#define SGP_VERS_RESERVED(data)        ((((data)->feature_set) & 0x0800) >> 11)
+#define SGP_VERS_GEN(data)     ((((data)->feature_set) & 0x0600) >> 9)
+#define SGP_VERS_ENG_BIT(data) ((((data)->feature_set) & 0x0100) >> 8)
+#define SGP_VERS_MAJOR(data)   ((((data)->feature_set) & 0x00e0) >> 5)
+#define SGP_VERS_MINOR(data)   (((data)->feature_set) & 0x001f)
+
+DECLARE_CRC8_TABLE(sgp_crc8_table);
+
+enum sgp_product_id {
+       SGP30 = 0,
+       SGPC3,
+};
+
+enum sgp30_channel_idx {
+       SGP30_IAQ_TVOC_IDX = 0,
+       SGP30_IAQ_CO2EQ_IDX,
+       SGP30_SIG_ETOH_IDX,
+       SGP30_SIG_H2_IDX,
+};
+
+enum sgpc3_channel_idx {
+       SGPC3_IAQ_TVOC_IDX = 10,
+       SGPC3_SIG_ETOH_IDX,
+};
+
+enum sgp_cmd {
+       SGP_CMD_IAQ_INIT                        = SGP_CMD(0x2003),
+       SGP_CMD_IAQ_MEASURE                     = SGP_CMD(0x2008),
+       SGP_CMD_GET_FEATURE_SET                 = SGP_CMD(0x202f),
+       SGP_CMD_GET_SERIAL_ID                   = SGP_CMD(0x3682),
+
+       SGP30_CMD_MEASURE_SIGNAL                = SGP_CMD(0x2050),
+
+       SGPC3_CMD_MEASURE_RAW                   = SGP_CMD(0x2046),
+};
+
+struct sgp_version {
+       u8 major;
+       u8 minor;
+};
+
+struct sgp_crc_word {
+       __be16 value;
+       u8 crc8;
+} __attribute__((__packed__));
+
+union sgp_reading {
+       u8 start;
+       struct sgp_crc_word raw_words[4];
+};
+
+enum _iaq_buffer_state {
+       IAQ_BUFFER_EMPTY = 0,
+       IAQ_BUFFER_DEFAULT_VALS,
+       IAQ_BUFFER_VALID,
+};
+
+struct sgp_data {
+       struct i2c_client *client;
+       struct task_struct *iaq_thread;
+       struct mutex data_lock;
+       unsigned long iaq_init_start_jiffies;
+       unsigned long iaq_defval_skip_jiffies;
+       u16 product_id;
+       u16 feature_set;
+       unsigned long measure_interval_jiffies;
+       enum sgp_cmd iaq_init_cmd;
+       enum sgp_cmd measure_iaq_cmd;
+       enum sgp_cmd measure_gas_signals_cmd;
+       union sgp_reading buffer;
+       union sgp_reading iaq_buffer;
+       enum _iaq_buffer_state iaq_buffer_state;
+};
+
+struct sgp_device {
+       const struct iio_chan_spec *channels;
+       int num_channels;
+};
+
+static const struct sgp_version supported_versions_sgp30[] = {
+       {
+               .major = 1,
+               .minor = 0,
+       },
+};
+
+static const struct sgp_version supported_versions_sgpc3[] = {
+       {
+               .major = 0,
+               .minor = 4,
+       },
+};
+
+static const struct iio_chan_spec sgp30_channels[] = {
+       {
+               .type = IIO_CONCENTRATION,
+               .channel2 = IIO_MOD_VOC,
+               .modified = 1,
+               .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED),
+               .address = SGP30_IAQ_TVOC_IDX,
+       },
+       {
+               .type = IIO_CONCENTRATION,
+               .channel2 = IIO_MOD_CO2,
+               .modified = 1,
+               .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED),
+               .address = SGP30_IAQ_CO2EQ_IDX,
+       },
+       {
+               .type = IIO_CONCENTRATION,
+               .channel2 = IIO_MOD_ETHANOL,
+               .modified = 1,
+               .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
+               .address = SGP30_SIG_ETOH_IDX,
+       },
+       {
+               .type = IIO_CONCENTRATION,
+               .channel2 = IIO_MOD_H2,
+               .modified = 1,
+               .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
+               .address = SGP30_SIG_H2_IDX,
+       },
+};
+
+static const struct iio_chan_spec sgpc3_channels[] = {
+       {
+               .type = IIO_CONCENTRATION,
+               .channel2 = IIO_MOD_VOC,
+               .modified = 1,
+               .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED),
+               .address = SGPC3_IAQ_TVOC_IDX,
+       },
+       {
+               .type = IIO_CONCENTRATION,
+               .channel2 = IIO_MOD_ETHANOL,
+               .modified = 1,
+               .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
+               .address = SGPC3_SIG_ETOH_IDX,
+       },
+};
+
+static const struct sgp_device sgp_devices[] = {
+       [SGP30] = {
+               .channels = sgp30_channels,
+               .num_channels = ARRAY_SIZE(sgp30_channels),
+       },
+       [SGPC3] = {
+               .channels = sgpc3_channels,
+               .num_channels = ARRAY_SIZE(sgpc3_channels),
+       },
+};
+
+/**
+ * sgp_verify_buffer() - verify the checksums of the data buffer words
+ *
+ * @data:       SGP data
+ * @buf:        Raw data buffer
+ * @word_count: Num data words stored in the buffer, excluding CRC bytes
+ *
+ * Return:      0 on success, negative error otherwise.
+ */
+static int sgp_verify_buffer(const struct sgp_data *data,
+                            union sgp_reading *buf, size_t word_count)
+{
+       size_t size = word_count * (SGP_WORD_LEN + SGP_CRC8_LEN);
+       int i;
+       u8 crc;
+       u8 *data_buf = &buf->start;
+
+       for (i = 0; i < size; i += SGP_WORD_LEN + SGP_CRC8_LEN) {
+               crc = crc8(sgp_crc8_table, &data_buf[i], SGP_WORD_LEN,
+                          SGP_CRC8_INIT);
+               if (crc != data_buf[i + SGP_WORD_LEN]) {
+                       dev_err(&data->client->dev, "CRC error\n");
+                       return -EIO;
+               }
+       }
+
+       return 0;
+}
+
+/**
+ * sgp_read_cmd() - reads data from sensor after issuing a command
+ * The caller must hold data->data_lock for the duration of the call.
+ * @data:        SGP data
+ * @cmd:         SGP Command to issue
+ * @buf:         Raw data buffer to use
+ * @word_count:  Num words to read, excluding CRC bytes
+ *
+ * Return:       0 on success, negative error otherwise.
+ */
+static int sgp_read_cmd(struct sgp_data *data, enum sgp_cmd cmd,
+                       union sgp_reading *buf, size_t word_count,
+                       unsigned long duration_us)
+{
+       int ret;
+       struct i2c_client *client = data->client;
+       size_t size = word_count * (SGP_WORD_LEN + SGP_CRC8_LEN);
+       u8 *data_buf;
+
+       ret = i2c_master_send(client, (const char *)&cmd, SGP_CMD_LEN);
+       if (ret != SGP_CMD_LEN)
+               return -EIO;
+       usleep_range(duration_us, duration_us + 1000);
+
+       if (word_count == 0)
+               return 0;
+
+       data_buf = &buf->start;
+       ret = i2c_master_recv(client, data_buf, size);
+       if (ret < 0)
+               return ret;
+       if (ret != size)
+               return -EIO;
+
+       return sgp_verify_buffer(data, buf, word_count);
+}
+
+/**
+ * sgp_measure_iaq() - measure and retrieve IAQ values from sensor
+ * The caller must hold data->data_lock for the duration of the call.
+ * @data:       SGP data
+ *
+ * Return:      0 on success, -EBUSY on default values, negative error
+ *              otherwise.
+ */
+
+static int sgp_measure_iaq(struct sgp_data *data)
+{
+       int ret;
+       /* data contains default values */
+       bool default_vals = !time_after(jiffies, data->iaq_init_start_jiffies +
+                                                data->iaq_defval_skip_jiffies);
+
+       ret = sgp_read_cmd(data, data->measure_iaq_cmd, &data->iaq_buffer,
+                          SGP_MEASUREMENT_LEN, SGP_MEASUREMENT_DURATION_US);
+       if (ret < 0)
+               return ret;
+
+       data->iaq_buffer_state = IAQ_BUFFER_DEFAULT_VALS;
+
+       if (default_vals)
+               return -EBUSY;
+
+       data->iaq_buffer_state = IAQ_BUFFER_VALID;
+
+       return 0;
+}
+
+static void sgp_iaq_thread_sleep_until(const struct sgp_data *data,
+                                      unsigned long sleep_jiffies)
+{
+       const long IAQ_POLL = 50000;
+
+       while (!time_after(jiffies, sleep_jiffies)) {
+               usleep_range(IAQ_POLL, IAQ_POLL + 10000);
+               if (kthread_should_stop() || data->iaq_init_start_jiffies == 0)
+                       return;
+       }
+}
+
+static int sgp_iaq_threadfn(void *p)
+{
+       struct sgp_data *data = (struct sgp_data *)p;
+       unsigned long next_update_jiffies;
+       int ret;
+
+       while (!kthread_should_stop()) {
+               mutex_lock(&data->data_lock);
+               if (data->iaq_init_start_jiffies == 0) {
+                       ret = sgp_read_cmd(data, data->iaq_init_cmd, NULL, 0,
+                                          SGP_CMD_DURATION_US);
+                       if (ret < 0)
+                               goto unlock_sleep_continue;
+                       data->iaq_init_start_jiffies = jiffies;
+               }
+
+               ret = sgp_measure_iaq(data);
+               if (ret && ret != -EBUSY) {
+                       dev_warn(&data->client->dev,
+                                "IAQ measurement error [%d]\n", ret);
+               }
+unlock_sleep_continue:
+               next_update_jiffies = jiffies + data->measure_interval_jiffies;
+               mutex_unlock(&data->data_lock);
+               sgp_iaq_thread_sleep_until(data, next_update_jiffies);
+       }
+
+       return 0;
+}
+
+static int sgp_read_raw(struct iio_dev *indio_dev,
+                       struct iio_chan_spec const *chan, int *val,
+                       int *val2, long mask)
+{
+       struct sgp_data *data = iio_priv(indio_dev);
+       struct sgp_crc_word *words;
+       int ret;
+
+       switch (mask) {
+       case IIO_CHAN_INFO_PROCESSED:
+               mutex_lock(&data->data_lock);
+               if (data->iaq_buffer_state != IAQ_BUFFER_VALID) {
+                       mutex_unlock(&data->data_lock);
+                       return -EBUSY;
+               }
+               words = data->iaq_buffer.raw_words;
+               switch (chan->address) {
+               case SGP30_IAQ_TVOC_IDX:
+               case SGPC3_IAQ_TVOC_IDX:
+                       *val = 0;
+                       *val2 = be16_to_cpu(words[1].value);
+                       ret = IIO_VAL_INT_PLUS_NANO;
+                       break;
+               case SGP30_IAQ_CO2EQ_IDX:
+                       *val = 0;
+                       *val2 = be16_to_cpu(words[0].value);
+                       ret = IIO_VAL_INT_PLUS_MICRO;
+                       break;
+               default:
+                       ret = -EINVAL;
+                       break;
+               }
+               mutex_unlock(&data->data_lock);
+               break;
+       case IIO_CHAN_INFO_RAW:
+               mutex_lock(&data->data_lock);
+               if (chan->address == SGPC3_SIG_ETOH_IDX) {
+                       if (data->iaq_buffer_state == IAQ_BUFFER_EMPTY)
+                               ret = -EBUSY;
+                       else
+                               ret = 0;
+                       words = data->iaq_buffer.raw_words;
+               } else {
+                       ret = sgp_read_cmd(data, data->measure_gas_signals_cmd,
+                                          &data->buffer, SGP_MEASUREMENT_LEN,
+                                          SGP_MEASUREMENT_DURATION_US);
+                       words = data->buffer.raw_words;
+               }
+               if (ret) {
+                       mutex_unlock(&data->data_lock);
+                       return ret;
+               }
+
+               switch (chan->address) {
+               case SGP30_SIG_ETOH_IDX:
+                       *val = be16_to_cpu(words[1].value);
+                       ret = IIO_VAL_INT;
+                       break;
+               case SGPC3_SIG_ETOH_IDX:
+               case SGP30_SIG_H2_IDX:
+                       *val = be16_to_cpu(words[0].value);
+                       ret = IIO_VAL_INT;
+                       break;
+               default:
+                       ret = -EINVAL;
+                       break;
+               }
+               mutex_unlock(&data->data_lock);
+               break;
+       default:
+               return -EINVAL;
+       }
+
+       return ret;
+}
+
+static int sgp_check_compat(struct sgp_data *data,
+                           unsigned int product_id)
+{
+       const struct sgp_version *supported_versions;
+       u16 ix, num_fs;
+       u16 product, generation, major, minor;
+
+       /* driver does not match product */
+       generation = SGP_VERS_GEN(data);
+       if (generation != 0) {
+               dev_err(&data->client->dev,
+                       "incompatible product generation %d != 0", generation);
+               return -ENODEV;
+       }
+
+       product = SGP_VERS_PRODUCT(data);
+       if (product != product_id) {
+               dev_err(&data->client->dev,
+                       "sensor reports a different product: 0x%04hx\n",
+                       product);
+               return -ENODEV;
+       }
+
+       if (SGP_VERS_RESERVED(data))
+               dev_warn(&data->client->dev, "reserved bit is set\n");
+
+       /* engineering samples are not supported: no interface guarantees */
+       if (SGP_VERS_ENG_BIT(data))
+               return -ENODEV;
+
+       switch (product) {
+       case SGP30:
+               supported_versions = supported_versions_sgp30;
+               num_fs = ARRAY_SIZE(supported_versions_sgp30);
+               break;
+       case SGPC3:
+               supported_versions = supported_versions_sgpc3;
+               num_fs = ARRAY_SIZE(supported_versions_sgpc3);
+               break;
+       default:
+               return -ENODEV;
+       }
+
+       major = SGP_VERS_MAJOR(data);
+       minor = SGP_VERS_MINOR(data);
+       for (ix = 0; ix < num_fs; ix++) {
+               if (major == supported_versions[ix].major &&
+                   minor >= supported_versions[ix].minor)
+                       return 0;
+       }
+       dev_err(&data->client->dev, "unsupported sgp version: %d.%d\n",
+               major, minor);
+
+       return -ENODEV;
+}
+
+static void sgp_init(struct sgp_data *data)
+{
+       data->iaq_init_cmd = SGP_CMD_IAQ_INIT;
+       data->iaq_init_start_jiffies = 0;
+       data->iaq_buffer_state = IAQ_BUFFER_EMPTY;
+       switch (SGP_VERS_PRODUCT(data)) {
+       case SGP30:
+               data->measure_interval_jiffies = SGP30_MEASURE_INTERVAL_HZ * HZ;
+               data->measure_iaq_cmd = SGP_CMD_IAQ_MEASURE;
+               data->measure_gas_signals_cmd = SGP30_CMD_MEASURE_SIGNAL;
+               data->product_id = SGP30;
+               data->iaq_defval_skip_jiffies = 15 * HZ;
+               break;
+       case SGPC3:
+               data->measure_interval_jiffies = SGPC3_MEASURE_INTERVAL_HZ * HZ;
+               data->measure_iaq_cmd = SGPC3_CMD_MEASURE_RAW;
+               data->measure_gas_signals_cmd = SGPC3_CMD_MEASURE_RAW;
+               data->product_id = SGPC3;
+               data->iaq_defval_skip_jiffies =
+                       43 * data->measure_interval_jiffies;
+               break;
+       };
+}
+
+static const struct iio_info sgp_info = {
+       .read_raw       = sgp_read_raw,
+};
+
+static const struct of_device_id sgp_dt_ids[] = {
+       { .compatible = "sensirion,sgp30", .data = (void *)SGP30 },
+       { .compatible = "sensirion,sgpc3", .data = (void *)SGPC3 },
+       { }
+};
+
+static int sgp_probe(struct i2c_client *client,
+                    const struct i2c_device_id *id)
+{
+       struct iio_dev *indio_dev;
+       struct sgp_data *data;
+       const struct of_device_id *of_id;
+       unsigned long product_id;
+       int ret;
+
+       indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
+       if (!indio_dev)
+               return -ENOMEM;
+
+       of_id = of_match_device(sgp_dt_ids, &client->dev);
+       if (of_id)
+               product_id = (unsigned long)of_id->data;
+       else
+               product_id = id->driver_data;
+
+       data = iio_priv(indio_dev);
+       i2c_set_clientdata(client, indio_dev);
+       data->client = client;
+       crc8_populate_msb(sgp_crc8_table, SGP_CRC8_POLYNOMIAL);
+       mutex_init(&data->data_lock);
+
+       /* get feature set version and write it to client data */
+       ret = sgp_read_cmd(data, SGP_CMD_GET_FEATURE_SET, &data->buffer, 1,
+                          SGP_CMD_DURATION_US);
+       if (ret < 0)
+               return ret;
+
+       data->feature_set = be16_to_cpu(data->buffer.raw_words[0].value);
+
+       ret = sgp_check_compat(data, product_id);
+       if (ret)
+               return ret;
+
+       indio_dev->dev.parent = &client->dev;
+       indio_dev->info = &sgp_info;
+       indio_dev->name = id->name;
+       indio_dev->modes = INDIO_DIRECT_MODE;
+       indio_dev->channels = sgp_devices[product_id].channels;
+       indio_dev->num_channels = sgp_devices[product_id].num_channels;
+
+       sgp_init(data);
+
+       ret = devm_iio_device_register(&client->dev, indio_dev);
+       if (ret) {
+               dev_err(&client->dev, "failed to register iio device\n");
+               return ret;
+       }
+
+       data->iaq_thread = kthread_run(sgp_iaq_threadfn, data,
+                                      "%s-iaq", data->client->name);
+
+       return 0;
+}
+
+static int sgp_remove(struct i2c_client *client)
+{
+       struct iio_dev *indio_dev = i2c_get_clientdata(client);
+       struct sgp_data *data = iio_priv(indio_dev);
+
+       if (data->iaq_thread)
+               kthread_stop(data->iaq_thread);
+
+       return 0;
+}
+
+static const struct i2c_device_id sgp_id[] = {
+       { "sgp30", SGP30 },
+       { "sgpc3", SGPC3 },
+       { }
+};
+
+MODULE_DEVICE_TABLE(i2c, sgp_id);
+MODULE_DEVICE_TABLE(of, sgp_dt_ids);
+
+static struct i2c_driver sgp_driver = {
+       .driver = {
+               .name = "sgp30",
+               .of_match_table = of_match_ptr(sgp_dt_ids),
+       },
+       .probe = sgp_probe,
+       .remove = sgp_remove,
+       .id_table = sgp_id,
+};
+module_i2c_driver(sgp_driver);
+
+MODULE_AUTHOR("Andreas Brauchli <andreas.brauchli@sensirion.com>");
+MODULE_AUTHOR("Pascal Sachs <pascal.sachs@sensirion.com>");
+MODULE_DESCRIPTION("Sensirion SGP gas sensors");
+MODULE_LICENSE("GPL v2");