iio: chemical: sgp30: Support Sensirion SGP30/SGPC3 sensors
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>
This commit is contained in:
Andreas Brauchli
Jonathan Cameron
parent
b170f7d484
commit
ce51412416
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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");
|
||||
Loading…
Reference in New Issue