Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  * sgp30.c - Support for Sensirion SGP Gas Sensors
0004  *
0005  * Copyright (C) 2018 Andreas Brauchli <andreas.brauchli@sensirion.com>
0006  *
0007  * I2C slave address: 0x58
0008  *
0009  * Datasheets:
0010  * https://www.sensirion.com/file/datasheet_sgp30
0011  * https://www.sensirion.com/file/datasheet_sgpc3
0012  *
0013  * TODO:
0014  * - baseline support
0015  * - humidity compensation
0016  * - power mode switching (SGPC3)
0017  */
0018 
0019 #include <linux/crc8.h>
0020 #include <linux/delay.h>
0021 #include <linux/kthread.h>
0022 #include <linux/module.h>
0023 #include <linux/mod_devicetable.h>
0024 #include <linux/mutex.h>
0025 #include <linux/i2c.h>
0026 #include <linux/iio/iio.h>
0027 #include <linux/iio/sysfs.h>
0028 
0029 #define SGP_WORD_LEN                2
0030 #define SGP_CRC8_POLYNOMIAL         0x31
0031 #define SGP_CRC8_INIT               0xff
0032 #define SGP_CRC8_LEN                1
0033 #define SGP_CMD(cmd_word)           cpu_to_be16(cmd_word)
0034 #define SGP_CMD_DURATION_US         12000
0035 #define SGP_MEASUREMENT_DURATION_US     50000
0036 #define SGP_CMD_LEN             SGP_WORD_LEN
0037 #define SGP_CMD_MAX_BUF_SIZE            (SGP_CMD_LEN + 2 * SGP_WORD_LEN)
0038 #define SGP_MEASUREMENT_LEN         2
0039 #define SGP30_MEASURE_INTERVAL_HZ       1
0040 #define SGPC3_MEASURE_INTERVAL_HZ       2
0041 #define SGP_VERS_PRODUCT(data)  ((((data)->feature_set) & 0xf000) >> 12)
0042 #define SGP_VERS_RESERVED(data) ((((data)->feature_set) & 0x0800) >> 11)
0043 #define SGP_VERS_GEN(data)  ((((data)->feature_set) & 0x0600) >> 9)
0044 #define SGP_VERS_ENG_BIT(data)  ((((data)->feature_set) & 0x0100) >> 8)
0045 #define SGP_VERS_MAJOR(data)    ((((data)->feature_set) & 0x00e0) >> 5)
0046 #define SGP_VERS_MINOR(data)    (((data)->feature_set) & 0x001f)
0047 
0048 DECLARE_CRC8_TABLE(sgp_crc8_table);
0049 
0050 enum sgp_product_id {
0051     SGP30 = 0,
0052     SGPC3,
0053 };
0054 
0055 enum sgp30_channel_idx {
0056     SGP30_IAQ_TVOC_IDX = 0,
0057     SGP30_IAQ_CO2EQ_IDX,
0058     SGP30_SIG_ETOH_IDX,
0059     SGP30_SIG_H2_IDX,
0060 };
0061 
0062 enum sgpc3_channel_idx {
0063     SGPC3_IAQ_TVOC_IDX = 10,
0064     SGPC3_SIG_ETOH_IDX,
0065 };
0066 
0067 enum sgp_cmd {
0068     SGP_CMD_IAQ_INIT            = SGP_CMD(0x2003),
0069     SGP_CMD_IAQ_MEASURE         = SGP_CMD(0x2008),
0070     SGP_CMD_GET_FEATURE_SET         = SGP_CMD(0x202f),
0071     SGP_CMD_GET_SERIAL_ID           = SGP_CMD(0x3682),
0072 
0073     SGP30_CMD_MEASURE_SIGNAL        = SGP_CMD(0x2050),
0074 
0075     SGPC3_CMD_MEASURE_RAW           = SGP_CMD(0x2046),
0076 };
0077 
0078 struct sgp_version {
0079     u8 major;
0080     u8 minor;
0081 };
0082 
0083 struct sgp_crc_word {
0084     __be16 value;
0085     u8 crc8;
0086 } __attribute__((__packed__));
0087 
0088 union sgp_reading {
0089     u8 start;
0090     struct sgp_crc_word raw_words[4];
0091 };
0092 
0093 enum _iaq_buffer_state {
0094     IAQ_BUFFER_EMPTY = 0,
0095     IAQ_BUFFER_DEFAULT_VALS,
0096     IAQ_BUFFER_VALID,
0097 };
0098 
0099 struct sgp_data {
0100     struct i2c_client *client;
0101     struct task_struct *iaq_thread;
0102     struct mutex data_lock;
0103     unsigned long iaq_init_start_jiffies;
0104     unsigned long iaq_defval_skip_jiffies;
0105     u16 product_id;
0106     u16 feature_set;
0107     unsigned long measure_interval_jiffies;
0108     enum sgp_cmd iaq_init_cmd;
0109     enum sgp_cmd measure_iaq_cmd;
0110     enum sgp_cmd measure_gas_signals_cmd;
0111     union sgp_reading buffer;
0112     union sgp_reading iaq_buffer;
0113     enum _iaq_buffer_state iaq_buffer_state;
0114 };
0115 
0116 struct sgp_device {
0117     const struct iio_chan_spec *channels;
0118     int num_channels;
0119 };
0120 
0121 static const struct sgp_version supported_versions_sgp30[] = {
0122     {
0123         .major = 1,
0124         .minor = 0,
0125     },
0126 };
0127 
0128 static const struct sgp_version supported_versions_sgpc3[] = {
0129     {
0130         .major = 0,
0131         .minor = 4,
0132     },
0133 };
0134 
0135 static const struct iio_chan_spec sgp30_channels[] = {
0136     {
0137         .type = IIO_CONCENTRATION,
0138         .channel2 = IIO_MOD_VOC,
0139         .modified = 1,
0140         .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED),
0141         .address = SGP30_IAQ_TVOC_IDX,
0142     },
0143     {
0144         .type = IIO_CONCENTRATION,
0145         .channel2 = IIO_MOD_CO2,
0146         .modified = 1,
0147         .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED),
0148         .address = SGP30_IAQ_CO2EQ_IDX,
0149     },
0150     {
0151         .type = IIO_CONCENTRATION,
0152         .channel2 = IIO_MOD_ETHANOL,
0153         .modified = 1,
0154         .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
0155         .address = SGP30_SIG_ETOH_IDX,
0156     },
0157     {
0158         .type = IIO_CONCENTRATION,
0159         .channel2 = IIO_MOD_H2,
0160         .modified = 1,
0161         .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
0162         .address = SGP30_SIG_H2_IDX,
0163     },
0164 };
0165 
0166 static const struct iio_chan_spec sgpc3_channels[] = {
0167     {
0168         .type = IIO_CONCENTRATION,
0169         .channel2 = IIO_MOD_VOC,
0170         .modified = 1,
0171         .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED),
0172         .address = SGPC3_IAQ_TVOC_IDX,
0173     },
0174     {
0175         .type = IIO_CONCENTRATION,
0176         .channel2 = IIO_MOD_ETHANOL,
0177         .modified = 1,
0178         .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
0179         .address = SGPC3_SIG_ETOH_IDX,
0180     },
0181 };
0182 
0183 static const struct sgp_device sgp_devices[] = {
0184     [SGP30] = {
0185         .channels = sgp30_channels,
0186         .num_channels = ARRAY_SIZE(sgp30_channels),
0187     },
0188     [SGPC3] = {
0189         .channels = sgpc3_channels,
0190         .num_channels = ARRAY_SIZE(sgpc3_channels),
0191     },
0192 };
0193 
0194 /**
0195  * sgp_verify_buffer() - verify the checksums of the data buffer words
0196  *
0197  * @data:       SGP data
0198  * @buf:        Raw data buffer
0199  * @word_count: Num data words stored in the buffer, excluding CRC bytes
0200  *
0201  * Return:      0 on success, negative error otherwise.
0202  */
0203 static int sgp_verify_buffer(const struct sgp_data *data,
0204                  union sgp_reading *buf, size_t word_count)
0205 {
0206     size_t size = word_count * (SGP_WORD_LEN + SGP_CRC8_LEN);
0207     int i;
0208     u8 crc;
0209     u8 *data_buf = &buf->start;
0210 
0211     for (i = 0; i < size; i += SGP_WORD_LEN + SGP_CRC8_LEN) {
0212         crc = crc8(sgp_crc8_table, &data_buf[i], SGP_WORD_LEN,
0213                SGP_CRC8_INIT);
0214         if (crc != data_buf[i + SGP_WORD_LEN]) {
0215             dev_err(&data->client->dev, "CRC error\n");
0216             return -EIO;
0217         }
0218     }
0219 
0220     return 0;
0221 }
0222 
0223 /**
0224  * sgp_read_cmd() - reads data from sensor after issuing a command
0225  * The caller must hold data->data_lock for the duration of the call.
0226  * @data:        SGP data
0227  * @cmd:         SGP Command to issue
0228  * @buf:         Raw data buffer to use
0229  * @word_count:  Num words to read, excluding CRC bytes
0230  * @duration_us: Time taken to sensor to take a reading and data to be ready.
0231  *
0232  * Return:       0 on success, negative error otherwise.
0233  */
0234 static int sgp_read_cmd(struct sgp_data *data, enum sgp_cmd cmd,
0235             union sgp_reading *buf, size_t word_count,
0236             unsigned long duration_us)
0237 {
0238     int ret;
0239     struct i2c_client *client = data->client;
0240     size_t size = word_count * (SGP_WORD_LEN + SGP_CRC8_LEN);
0241     u8 *data_buf;
0242 
0243     ret = i2c_master_send(client, (const char *)&cmd, SGP_CMD_LEN);
0244     if (ret != SGP_CMD_LEN)
0245         return -EIO;
0246     usleep_range(duration_us, duration_us + 1000);
0247 
0248     if (word_count == 0)
0249         return 0;
0250 
0251     data_buf = &buf->start;
0252     ret = i2c_master_recv(client, data_buf, size);
0253     if (ret < 0)
0254         return ret;
0255     if (ret != size)
0256         return -EIO;
0257 
0258     return sgp_verify_buffer(data, buf, word_count);
0259 }
0260 
0261 /**
0262  * sgp_measure_iaq() - measure and retrieve IAQ values from sensor
0263  * The caller must hold data->data_lock for the duration of the call.
0264  * @data:       SGP data
0265  *
0266  * Return:      0 on success, -EBUSY on default values, negative error
0267  *              otherwise.
0268  */
0269 
0270 static int sgp_measure_iaq(struct sgp_data *data)
0271 {
0272     int ret;
0273     /* data contains default values */
0274     bool default_vals = !time_after(jiffies, data->iaq_init_start_jiffies +
0275                          data->iaq_defval_skip_jiffies);
0276 
0277     ret = sgp_read_cmd(data, data->measure_iaq_cmd, &data->iaq_buffer,
0278                SGP_MEASUREMENT_LEN, SGP_MEASUREMENT_DURATION_US);
0279     if (ret < 0)
0280         return ret;
0281 
0282     data->iaq_buffer_state = IAQ_BUFFER_DEFAULT_VALS;
0283 
0284     if (default_vals)
0285         return -EBUSY;
0286 
0287     data->iaq_buffer_state = IAQ_BUFFER_VALID;
0288 
0289     return 0;
0290 }
0291 
0292 static void sgp_iaq_thread_sleep_until(const struct sgp_data *data,
0293                        unsigned long sleep_jiffies)
0294 {
0295     const long IAQ_POLL = 50000;
0296 
0297     while (!time_after(jiffies, sleep_jiffies)) {
0298         usleep_range(IAQ_POLL, IAQ_POLL + 10000);
0299         if (kthread_should_stop() || data->iaq_init_start_jiffies == 0)
0300             return;
0301     }
0302 }
0303 
0304 static int sgp_iaq_threadfn(void *p)
0305 {
0306     struct sgp_data *data = (struct sgp_data *)p;
0307     unsigned long next_update_jiffies;
0308     int ret;
0309 
0310     while (!kthread_should_stop()) {
0311         mutex_lock(&data->data_lock);
0312         if (data->iaq_init_start_jiffies == 0) {
0313             ret = sgp_read_cmd(data, data->iaq_init_cmd, NULL, 0,
0314                        SGP_CMD_DURATION_US);
0315             if (ret < 0)
0316                 goto unlock_sleep_continue;
0317             data->iaq_init_start_jiffies = jiffies;
0318         }
0319 
0320         ret = sgp_measure_iaq(data);
0321         if (ret && ret != -EBUSY) {
0322             dev_warn(&data->client->dev,
0323                  "IAQ measurement error [%d]\n", ret);
0324         }
0325 unlock_sleep_continue:
0326         next_update_jiffies = jiffies + data->measure_interval_jiffies;
0327         mutex_unlock(&data->data_lock);
0328         sgp_iaq_thread_sleep_until(data, next_update_jiffies);
0329     }
0330 
0331     return 0;
0332 }
0333 
0334 static int sgp_read_raw(struct iio_dev *indio_dev,
0335             struct iio_chan_spec const *chan, int *val,
0336             int *val2, long mask)
0337 {
0338     struct sgp_data *data = iio_priv(indio_dev);
0339     struct sgp_crc_word *words;
0340     int ret;
0341 
0342     switch (mask) {
0343     case IIO_CHAN_INFO_PROCESSED:
0344         mutex_lock(&data->data_lock);
0345         if (data->iaq_buffer_state != IAQ_BUFFER_VALID) {
0346             mutex_unlock(&data->data_lock);
0347             return -EBUSY;
0348         }
0349         words = data->iaq_buffer.raw_words;
0350         switch (chan->address) {
0351         case SGP30_IAQ_TVOC_IDX:
0352         case SGPC3_IAQ_TVOC_IDX:
0353             *val = 0;
0354             *val2 = be16_to_cpu(words[1].value);
0355             ret = IIO_VAL_INT_PLUS_NANO;
0356             break;
0357         case SGP30_IAQ_CO2EQ_IDX:
0358             *val = 0;
0359             *val2 = be16_to_cpu(words[0].value);
0360             ret = IIO_VAL_INT_PLUS_MICRO;
0361             break;
0362         default:
0363             ret = -EINVAL;
0364             break;
0365         }
0366         mutex_unlock(&data->data_lock);
0367         break;
0368     case IIO_CHAN_INFO_RAW:
0369         mutex_lock(&data->data_lock);
0370         if (chan->address == SGPC3_SIG_ETOH_IDX) {
0371             if (data->iaq_buffer_state == IAQ_BUFFER_EMPTY)
0372                 ret = -EBUSY;
0373             else
0374                 ret = 0;
0375             words = data->iaq_buffer.raw_words;
0376         } else {
0377             ret = sgp_read_cmd(data, data->measure_gas_signals_cmd,
0378                        &data->buffer, SGP_MEASUREMENT_LEN,
0379                        SGP_MEASUREMENT_DURATION_US);
0380             words = data->buffer.raw_words;
0381         }
0382         if (ret) {
0383             mutex_unlock(&data->data_lock);
0384             return ret;
0385         }
0386 
0387         switch (chan->address) {
0388         case SGP30_SIG_ETOH_IDX:
0389             *val = be16_to_cpu(words[1].value);
0390             ret = IIO_VAL_INT;
0391             break;
0392         case SGPC3_SIG_ETOH_IDX:
0393         case SGP30_SIG_H2_IDX:
0394             *val = be16_to_cpu(words[0].value);
0395             ret = IIO_VAL_INT;
0396             break;
0397         default:
0398             ret = -EINVAL;
0399             break;
0400         }
0401         mutex_unlock(&data->data_lock);
0402         break;
0403     default:
0404         return -EINVAL;
0405     }
0406 
0407     return ret;
0408 }
0409 
0410 static int sgp_check_compat(struct sgp_data *data,
0411                 unsigned int product_id)
0412 {
0413     struct device *dev = &data->client->dev;
0414     const struct sgp_version *supported_versions;
0415     u16 ix, num_fs;
0416     u16 product, generation, major, minor;
0417 
0418     /* driver does not match product */
0419     generation = SGP_VERS_GEN(data);
0420     if (generation != 0) {
0421         dev_err(dev,
0422             "incompatible product generation %d != 0", generation);
0423         return -ENODEV;
0424     }
0425 
0426     product = SGP_VERS_PRODUCT(data);
0427     if (product != product_id) {
0428         dev_err(dev, "sensor reports a different product: 0x%04x\n",
0429             product);
0430         return -ENODEV;
0431     }
0432 
0433     if (SGP_VERS_RESERVED(data))
0434         dev_warn(dev, "reserved bit is set\n");
0435 
0436     /* engineering samples are not supported: no interface guarantees */
0437     if (SGP_VERS_ENG_BIT(data))
0438         return -ENODEV;
0439 
0440     switch (product) {
0441     case SGP30:
0442         supported_versions = supported_versions_sgp30;
0443         num_fs = ARRAY_SIZE(supported_versions_sgp30);
0444         break;
0445     case SGPC3:
0446         supported_versions = supported_versions_sgpc3;
0447         num_fs = ARRAY_SIZE(supported_versions_sgpc3);
0448         break;
0449     default:
0450         return -ENODEV;
0451     }
0452 
0453     major = SGP_VERS_MAJOR(data);
0454     minor = SGP_VERS_MINOR(data);
0455     for (ix = 0; ix < num_fs; ix++) {
0456         if (major == supported_versions[ix].major &&
0457             minor >= supported_versions[ix].minor)
0458             return 0;
0459     }
0460     dev_err(dev, "unsupported sgp version: %d.%d\n", major, minor);
0461 
0462     return -ENODEV;
0463 }
0464 
0465 static void sgp_init(struct sgp_data *data)
0466 {
0467     data->iaq_init_cmd = SGP_CMD_IAQ_INIT;
0468     data->iaq_init_start_jiffies = 0;
0469     data->iaq_buffer_state = IAQ_BUFFER_EMPTY;
0470     switch (SGP_VERS_PRODUCT(data)) {
0471     case SGP30:
0472         data->measure_interval_jiffies = SGP30_MEASURE_INTERVAL_HZ * HZ;
0473         data->measure_iaq_cmd = SGP_CMD_IAQ_MEASURE;
0474         data->measure_gas_signals_cmd = SGP30_CMD_MEASURE_SIGNAL;
0475         data->product_id = SGP30;
0476         data->iaq_defval_skip_jiffies = 15 * HZ;
0477         break;
0478     case SGPC3:
0479         data->measure_interval_jiffies = SGPC3_MEASURE_INTERVAL_HZ * HZ;
0480         data->measure_iaq_cmd = SGPC3_CMD_MEASURE_RAW;
0481         data->measure_gas_signals_cmd = SGPC3_CMD_MEASURE_RAW;
0482         data->product_id = SGPC3;
0483         data->iaq_defval_skip_jiffies =
0484             43 * data->measure_interval_jiffies;
0485         break;
0486     }
0487 }
0488 
0489 static const struct iio_info sgp_info = {
0490     .read_raw   = sgp_read_raw,
0491 };
0492 
0493 static const struct of_device_id sgp_dt_ids[] = {
0494     { .compatible = "sensirion,sgp30", .data = (void *)SGP30 },
0495     { .compatible = "sensirion,sgpc3", .data = (void *)SGPC3 },
0496     { }
0497 };
0498 
0499 static int sgp_probe(struct i2c_client *client,
0500              const struct i2c_device_id *id)
0501 {
0502     struct device *dev = &client->dev;
0503     struct iio_dev *indio_dev;
0504     struct sgp_data *data;
0505     unsigned long product_id;
0506     int ret;
0507 
0508     indio_dev = devm_iio_device_alloc(dev, sizeof(*data));
0509     if (!indio_dev)
0510         return -ENOMEM;
0511 
0512     if (dev_fwnode(dev))
0513         product_id = (unsigned long)device_get_match_data(dev);
0514     else
0515         product_id = id->driver_data;
0516 
0517     data = iio_priv(indio_dev);
0518     i2c_set_clientdata(client, indio_dev);
0519     data->client = client;
0520     crc8_populate_msb(sgp_crc8_table, SGP_CRC8_POLYNOMIAL);
0521     mutex_init(&data->data_lock);
0522 
0523     /* get feature set version and write it to client data */
0524     ret = sgp_read_cmd(data, SGP_CMD_GET_FEATURE_SET, &data->buffer, 1,
0525                SGP_CMD_DURATION_US);
0526     if (ret < 0)
0527         return ret;
0528 
0529     data->feature_set = be16_to_cpu(data->buffer.raw_words[0].value);
0530 
0531     ret = sgp_check_compat(data, product_id);
0532     if (ret)
0533         return ret;
0534 
0535     indio_dev->info = &sgp_info;
0536     indio_dev->name = id->name;
0537     indio_dev->modes = INDIO_DIRECT_MODE;
0538     indio_dev->channels = sgp_devices[product_id].channels;
0539     indio_dev->num_channels = sgp_devices[product_id].num_channels;
0540 
0541     sgp_init(data);
0542 
0543     ret = devm_iio_device_register(dev, indio_dev);
0544     if (ret) {
0545         dev_err(dev, "failed to register iio device\n");
0546         return ret;
0547     }
0548 
0549     data->iaq_thread = kthread_run(sgp_iaq_threadfn, data,
0550                        "%s-iaq", data->client->name);
0551 
0552     return 0;
0553 }
0554 
0555 static int sgp_remove(struct i2c_client *client)
0556 {
0557     struct iio_dev *indio_dev = i2c_get_clientdata(client);
0558     struct sgp_data *data = iio_priv(indio_dev);
0559 
0560     if (data->iaq_thread)
0561         kthread_stop(data->iaq_thread);
0562 
0563     return 0;
0564 }
0565 
0566 static const struct i2c_device_id sgp_id[] = {
0567     { "sgp30", SGP30 },
0568     { "sgpc3", SGPC3 },
0569     { }
0570 };
0571 
0572 MODULE_DEVICE_TABLE(i2c, sgp_id);
0573 MODULE_DEVICE_TABLE(of, sgp_dt_ids);
0574 
0575 static struct i2c_driver sgp_driver = {
0576     .driver = {
0577         .name = "sgp30",
0578         .of_match_table = sgp_dt_ids,
0579     },
0580     .probe = sgp_probe,
0581     .remove = sgp_remove,
0582     .id_table = sgp_id,
0583 };
0584 module_i2c_driver(sgp_driver);
0585 
0586 MODULE_AUTHOR("Andreas Brauchli <andreas.brauchli@sensirion.com>");
0587 MODULE_AUTHOR("Pascal Sachs <pascal.sachs@sensirion.com>");
0588 MODULE_DESCRIPTION("Sensirion SGP gas sensors");
0589 MODULE_LICENSE("GPL v2");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!