1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * sgp30.c - Support for Sensirion SGP Gas Sensors
4 *
5 * Copyright (C) 2018 Andreas Brauchli <andreas.brauchli@sensirion.com>
6 *
7 * I2C slave address: 0x58
8 *
9 * Datasheets:
10 * https://www.sensirion.com/file/datasheet_sgp30
11 * https://www.sensirion.com/file/datasheet_sgpc3
12 *
13 * TODO:
14 * - baseline support
15 * - humidity compensation
16 * - power mode switching (SGPC3)
17 */
18
19 #include <linux/crc8.h>
20 #include <linux/delay.h>
21 #include <linux/kthread.h>
22 #include <linux/module.h>
23 #include <linux/mutex.h>
24 #include <linux/i2c.h>
25 #include <linux/iio/iio.h>
26 #include <linux/iio/sysfs.h>
27
28 #define SGP_WORD_LEN 2
29 #define SGP_CRC8_POLYNOMIAL 0x31
30 #define SGP_CRC8_INIT 0xff
31 #define SGP_CRC8_LEN 1
32 #define SGP_CMD(cmd_word) cpu_to_be16(cmd_word)
33 #define SGP_CMD_DURATION_US 12000
34 #define SGP_MEASUREMENT_DURATION_US 50000
35 #define SGP_CMD_LEN SGP_WORD_LEN
36 #define SGP_CMD_MAX_BUF_SIZE (SGP_CMD_LEN + 2 * SGP_WORD_LEN)
37 #define SGP_MEASUREMENT_LEN 2
38 #define SGP30_MEASURE_INTERVAL_HZ 1
39 #define SGPC3_MEASURE_INTERVAL_HZ 2
40 #define SGP_VERS_PRODUCT(data) ((((data)->feature_set) & 0xf000) >> 12)
41 #define SGP_VERS_RESERVED(data) ((((data)->feature_set) & 0x0800) >> 11)
42 #define SGP_VERS_GEN(data) ((((data)->feature_set) & 0x0600) >> 9)
43 #define SGP_VERS_ENG_BIT(data) ((((data)->feature_set) & 0x0100) >> 8)
44 #define SGP_VERS_MAJOR(data) ((((data)->feature_set) & 0x00e0) >> 5)
45 #define SGP_VERS_MINOR(data) (((data)->feature_set) & 0x001f)
46
47 DECLARE_CRC8_TABLE(sgp_crc8_table);
48
49 enum sgp_product_id {
50 SGP30 = 0,
51 SGPC3,
52 };
53
54 enum sgp30_channel_idx {
55 SGP30_IAQ_TVOC_IDX = 0,
56 SGP30_IAQ_CO2EQ_IDX,
57 SGP30_SIG_ETOH_IDX,
58 SGP30_SIG_H2_IDX,
59 };
60
61 enum sgpc3_channel_idx {
62 SGPC3_IAQ_TVOC_IDX = 10,
63 SGPC3_SIG_ETOH_IDX,
64 };
65
66 enum sgp_cmd {
67 SGP_CMD_IAQ_INIT = SGP_CMD(0x2003),
68 SGP_CMD_IAQ_MEASURE = SGP_CMD(0x2008),
69 SGP_CMD_GET_FEATURE_SET = SGP_CMD(0x202f),
70 SGP_CMD_GET_SERIAL_ID = SGP_CMD(0x3682),
71
72 SGP30_CMD_MEASURE_SIGNAL = SGP_CMD(0x2050),
73
74 SGPC3_CMD_MEASURE_RAW = SGP_CMD(0x2046),
75 };
76
77 struct sgp_version {
78 u8 major;
79 u8 minor;
80 };
81
82 struct sgp_crc_word {
83 __be16 value;
84 u8 crc8;
85 } __attribute__((__packed__));
86
87 union sgp_reading {
88 u8 start;
89 struct sgp_crc_word raw_words[4];
90 };
91
92 enum _iaq_buffer_state {
93 IAQ_BUFFER_EMPTY = 0,
94 IAQ_BUFFER_DEFAULT_VALS,
95 IAQ_BUFFER_VALID,
96 };
97
98 struct sgp_data {
99 struct i2c_client *client;
100 struct task_struct *iaq_thread;
101 struct mutex data_lock;
102 unsigned long iaq_init_start_jiffies;
103 unsigned long iaq_defval_skip_jiffies;
104 u16 product_id;
105 u16 feature_set;
106 unsigned long measure_interval_jiffies;
107 enum sgp_cmd iaq_init_cmd;
108 enum sgp_cmd measure_iaq_cmd;
109 enum sgp_cmd measure_gas_signals_cmd;
110 union sgp_reading buffer;
111 union sgp_reading iaq_buffer;
112 enum _iaq_buffer_state iaq_buffer_state;
113 };
114
115 struct sgp_device {
116 unsigned long product_id;
117 const struct iio_chan_spec *channels;
118 int num_channels;
119 };
120
121 static const struct sgp_version supported_versions_sgp30[] = {
122 {
123 .major = 1,
124 .minor = 0,
125 },
126 };
127
128 static const struct sgp_version supported_versions_sgpc3[] = {
129 {
130 .major = 0,
131 .minor = 4,
132 },
133 };
134
135 static const struct iio_chan_spec sgp30_channels[] = {
136 {
137 .type = IIO_CONCENTRATION,
138 .channel2 = IIO_MOD_VOC,
139 .modified = 1,
140 .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED),
141 .address = SGP30_IAQ_TVOC_IDX,
142 },
143 {
144 .type = IIO_CONCENTRATION,
145 .channel2 = IIO_MOD_CO2,
146 .modified = 1,
147 .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED),
148 .address = SGP30_IAQ_CO2EQ_IDX,
149 },
150 {
151 .type = IIO_CONCENTRATION,
152 .channel2 = IIO_MOD_ETHANOL,
153 .modified = 1,
154 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
155 .address = SGP30_SIG_ETOH_IDX,
156 },
157 {
158 .type = IIO_CONCENTRATION,
159 .channel2 = IIO_MOD_H2,
160 .modified = 1,
161 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
162 .address = SGP30_SIG_H2_IDX,
163 },
164 };
165
166 static const struct iio_chan_spec sgpc3_channels[] = {
167 {
168 .type = IIO_CONCENTRATION,
169 .channel2 = IIO_MOD_VOC,
170 .modified = 1,
171 .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED),
172 .address = SGPC3_IAQ_TVOC_IDX,
173 },
174 {
175 .type = IIO_CONCENTRATION,
176 .channel2 = IIO_MOD_ETHANOL,
177 .modified = 1,
178 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
179 .address = SGPC3_SIG_ETOH_IDX,
180 },
181 };
182
183 static const struct sgp_device sgp_devices[] = {
184 [SGP30] = {
185 .product_id = SGP30,
186 .channels = sgp30_channels,
187 .num_channels = ARRAY_SIZE(sgp30_channels),
188 },
189 [SGPC3] = {
190 .product_id = SGPC3,
191 .channels = sgpc3_channels,
192 .num_channels = ARRAY_SIZE(sgpc3_channels),
193 },
194 };
195
196 /**
197 * sgp_verify_buffer() - verify the checksums of the data buffer words
198 *
199 * @data: SGP data
200 * @buf: Raw data buffer
201 * @word_count: Num data words stored in the buffer, excluding CRC bytes
202 *
203 * Return: 0 on success, negative error otherwise.
204 */
sgp_verify_buffer(const struct sgp_data * data,union sgp_reading * buf,size_t word_count)205 static int sgp_verify_buffer(const struct sgp_data *data,
206 union sgp_reading *buf, size_t word_count)
207 {
208 size_t size = word_count * (SGP_WORD_LEN + SGP_CRC8_LEN);
209 int i;
210 u8 crc;
211 u8 *data_buf = &buf->start;
212
213 for (i = 0; i < size; i += SGP_WORD_LEN + SGP_CRC8_LEN) {
214 crc = crc8(sgp_crc8_table, &data_buf[i], SGP_WORD_LEN,
215 SGP_CRC8_INIT);
216 if (crc != data_buf[i + SGP_WORD_LEN]) {
217 dev_err(&data->client->dev, "CRC error\n");
218 return -EIO;
219 }
220 }
221
222 return 0;
223 }
224
225 /**
226 * sgp_read_cmd() - reads data from sensor after issuing a command
227 * The caller must hold data->data_lock for the duration of the call.
228 * @data: SGP data
229 * @cmd: SGP Command to issue
230 * @buf: Raw data buffer to use
231 * @word_count: Num words to read, excluding CRC bytes
232 * @duration_us: Time taken to sensor to take a reading and data to be ready.
233 *
234 * Return: 0 on success, negative error otherwise.
235 */
sgp_read_cmd(struct sgp_data * data,enum sgp_cmd cmd,union sgp_reading * buf,size_t word_count,unsigned long duration_us)236 static int sgp_read_cmd(struct sgp_data *data, enum sgp_cmd cmd,
237 union sgp_reading *buf, size_t word_count,
238 unsigned long duration_us)
239 {
240 int ret;
241 struct i2c_client *client = data->client;
242 size_t size = word_count * (SGP_WORD_LEN + SGP_CRC8_LEN);
243 u8 *data_buf;
244
245 ret = i2c_master_send(client, (const char *)&cmd, SGP_CMD_LEN);
246 if (ret != SGP_CMD_LEN)
247 return -EIO;
248 usleep_range(duration_us, duration_us + 1000);
249
250 if (word_count == 0)
251 return 0;
252
253 data_buf = &buf->start;
254 ret = i2c_master_recv(client, data_buf, size);
255 if (ret < 0)
256 return ret;
257 if (ret != size)
258 return -EIO;
259
260 return sgp_verify_buffer(data, buf, word_count);
261 }
262
263 /**
264 * sgp_measure_iaq() - measure and retrieve IAQ values from sensor
265 * The caller must hold data->data_lock for the duration of the call.
266 * @data: SGP data
267 *
268 * Return: 0 on success, -EBUSY on default values, negative error
269 * otherwise.
270 */
271
sgp_measure_iaq(struct sgp_data * data)272 static int sgp_measure_iaq(struct sgp_data *data)
273 {
274 int ret;
275 /* data contains default values */
276 bool default_vals = !time_after(jiffies, data->iaq_init_start_jiffies +
277 data->iaq_defval_skip_jiffies);
278
279 ret = sgp_read_cmd(data, data->measure_iaq_cmd, &data->iaq_buffer,
280 SGP_MEASUREMENT_LEN, SGP_MEASUREMENT_DURATION_US);
281 if (ret < 0)
282 return ret;
283
284 data->iaq_buffer_state = IAQ_BUFFER_DEFAULT_VALS;
285
286 if (default_vals)
287 return -EBUSY;
288
289 data->iaq_buffer_state = IAQ_BUFFER_VALID;
290
291 return 0;
292 }
293
sgp_iaq_thread_sleep_until(const struct sgp_data * data,unsigned long sleep_jiffies)294 static void sgp_iaq_thread_sleep_until(const struct sgp_data *data,
295 unsigned long sleep_jiffies)
296 {
297 const long IAQ_POLL = 50000;
298
299 while (!time_after(jiffies, sleep_jiffies)) {
300 usleep_range(IAQ_POLL, IAQ_POLL + 10000);
301 if (kthread_should_stop() || data->iaq_init_start_jiffies == 0)
302 return;
303 }
304 }
305
sgp_iaq_threadfn(void * p)306 static int sgp_iaq_threadfn(void *p)
307 {
308 struct sgp_data *data = (struct sgp_data *)p;
309 unsigned long next_update_jiffies;
310 int ret;
311
312 while (!kthread_should_stop()) {
313 mutex_lock(&data->data_lock);
314 if (data->iaq_init_start_jiffies == 0) {
315 ret = sgp_read_cmd(data, data->iaq_init_cmd, NULL, 0,
316 SGP_CMD_DURATION_US);
317 if (ret < 0)
318 goto unlock_sleep_continue;
319 data->iaq_init_start_jiffies = jiffies;
320 }
321
322 ret = sgp_measure_iaq(data);
323 if (ret && ret != -EBUSY) {
324 dev_warn(&data->client->dev,
325 "IAQ measurement error [%d]\n", ret);
326 }
327 unlock_sleep_continue:
328 next_update_jiffies = jiffies + data->measure_interval_jiffies;
329 mutex_unlock(&data->data_lock);
330 sgp_iaq_thread_sleep_until(data, next_update_jiffies);
331 }
332
333 return 0;
334 }
335
sgp_read_raw(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,int * val,int * val2,long mask)336 static int sgp_read_raw(struct iio_dev *indio_dev,
337 struct iio_chan_spec const *chan, int *val,
338 int *val2, long mask)
339 {
340 struct sgp_data *data = iio_priv(indio_dev);
341 struct sgp_crc_word *words;
342 int ret;
343
344 switch (mask) {
345 case IIO_CHAN_INFO_PROCESSED:
346 mutex_lock(&data->data_lock);
347 if (data->iaq_buffer_state != IAQ_BUFFER_VALID) {
348 mutex_unlock(&data->data_lock);
349 return -EBUSY;
350 }
351 words = data->iaq_buffer.raw_words;
352 switch (chan->address) {
353 case SGP30_IAQ_TVOC_IDX:
354 case SGPC3_IAQ_TVOC_IDX:
355 *val = 0;
356 *val2 = be16_to_cpu(words[1].value);
357 ret = IIO_VAL_INT_PLUS_NANO;
358 break;
359 case SGP30_IAQ_CO2EQ_IDX:
360 *val = 0;
361 *val2 = be16_to_cpu(words[0].value);
362 ret = IIO_VAL_INT_PLUS_MICRO;
363 break;
364 default:
365 ret = -EINVAL;
366 break;
367 }
368 mutex_unlock(&data->data_lock);
369 break;
370 case IIO_CHAN_INFO_RAW:
371 mutex_lock(&data->data_lock);
372 if (chan->address == SGPC3_SIG_ETOH_IDX) {
373 if (data->iaq_buffer_state == IAQ_BUFFER_EMPTY)
374 ret = -EBUSY;
375 else
376 ret = 0;
377 words = data->iaq_buffer.raw_words;
378 } else {
379 ret = sgp_read_cmd(data, data->measure_gas_signals_cmd,
380 &data->buffer, SGP_MEASUREMENT_LEN,
381 SGP_MEASUREMENT_DURATION_US);
382 words = data->buffer.raw_words;
383 }
384 if (ret) {
385 mutex_unlock(&data->data_lock);
386 return ret;
387 }
388
389 switch (chan->address) {
390 case SGP30_SIG_ETOH_IDX:
391 *val = be16_to_cpu(words[1].value);
392 ret = IIO_VAL_INT;
393 break;
394 case SGPC3_SIG_ETOH_IDX:
395 case SGP30_SIG_H2_IDX:
396 *val = be16_to_cpu(words[0].value);
397 ret = IIO_VAL_INT;
398 break;
399 default:
400 ret = -EINVAL;
401 break;
402 }
403 mutex_unlock(&data->data_lock);
404 break;
405 default:
406 return -EINVAL;
407 }
408
409 return ret;
410 }
411
sgp_check_compat(struct sgp_data * data,unsigned int product_id)412 static int sgp_check_compat(struct sgp_data *data,
413 unsigned int product_id)
414 {
415 struct device *dev = &data->client->dev;
416 const struct sgp_version *supported_versions;
417 u16 ix, num_fs;
418 u16 product, generation, major, minor;
419
420 /* driver does not match product */
421 generation = SGP_VERS_GEN(data);
422 if (generation != 0) {
423 dev_err(dev,
424 "incompatible product generation %d != 0", generation);
425 return -ENODEV;
426 }
427
428 product = SGP_VERS_PRODUCT(data);
429 if (product != product_id) {
430 dev_err(dev, "sensor reports a different product: 0x%04x\n",
431 product);
432 return -ENODEV;
433 }
434
435 if (SGP_VERS_RESERVED(data))
436 dev_warn(dev, "reserved bit is set\n");
437
438 /* engineering samples are not supported: no interface guarantees */
439 if (SGP_VERS_ENG_BIT(data))
440 return -ENODEV;
441
442 switch (product) {
443 case SGP30:
444 supported_versions = supported_versions_sgp30;
445 num_fs = ARRAY_SIZE(supported_versions_sgp30);
446 break;
447 case SGPC3:
448 supported_versions = supported_versions_sgpc3;
449 num_fs = ARRAY_SIZE(supported_versions_sgpc3);
450 break;
451 default:
452 return -ENODEV;
453 }
454
455 major = SGP_VERS_MAJOR(data);
456 minor = SGP_VERS_MINOR(data);
457 for (ix = 0; ix < num_fs; ix++) {
458 if (major == supported_versions[ix].major &&
459 minor >= supported_versions[ix].minor)
460 return 0;
461 }
462 dev_err(dev, "unsupported sgp version: %d.%d\n", major, minor);
463
464 return -ENODEV;
465 }
466
sgp_init(struct sgp_data * data)467 static void sgp_init(struct sgp_data *data)
468 {
469 data->iaq_init_cmd = SGP_CMD_IAQ_INIT;
470 data->iaq_init_start_jiffies = 0;
471 data->iaq_buffer_state = IAQ_BUFFER_EMPTY;
472 switch (SGP_VERS_PRODUCT(data)) {
473 case SGP30:
474 data->measure_interval_jiffies = SGP30_MEASURE_INTERVAL_HZ * HZ;
475 data->measure_iaq_cmd = SGP_CMD_IAQ_MEASURE;
476 data->measure_gas_signals_cmd = SGP30_CMD_MEASURE_SIGNAL;
477 data->product_id = SGP30;
478 data->iaq_defval_skip_jiffies = 15 * HZ;
479 break;
480 case SGPC3:
481 data->measure_interval_jiffies = SGPC3_MEASURE_INTERVAL_HZ * HZ;
482 data->measure_iaq_cmd = SGPC3_CMD_MEASURE_RAW;
483 data->measure_gas_signals_cmd = SGPC3_CMD_MEASURE_RAW;
484 data->product_id = SGPC3;
485 data->iaq_defval_skip_jiffies =
486 43 * data->measure_interval_jiffies;
487 break;
488 }
489 }
490
491 static const struct iio_info sgp_info = {
492 .read_raw = sgp_read_raw,
493 };
494
495 static const struct of_device_id sgp_dt_ids[] = {
496 { .compatible = "sensirion,sgp30", .data = &sgp_devices[SGP30] },
497 { .compatible = "sensirion,sgpc3", .data = &sgp_devices[SGPC3] },
498 { }
499 };
500 MODULE_DEVICE_TABLE(of, sgp_dt_ids);
501
sgp_probe(struct i2c_client * client)502 static int sgp_probe(struct i2c_client *client)
503 {
504 const struct i2c_device_id *id = i2c_client_get_device_id(client);
505 const struct sgp_device *match_data;
506 struct device *dev = &client->dev;
507 struct iio_dev *indio_dev;
508 struct sgp_data *data;
509 int ret;
510
511 indio_dev = devm_iio_device_alloc(dev, sizeof(*data));
512 if (!indio_dev)
513 return -ENOMEM;
514
515 match_data = i2c_get_match_data(client);
516
517 data = iio_priv(indio_dev);
518 i2c_set_clientdata(client, indio_dev);
519 data->client = client;
520 crc8_populate_msb(sgp_crc8_table, SGP_CRC8_POLYNOMIAL);
521 mutex_init(&data->data_lock);
522
523 /* get feature set version and write it to client data */
524 ret = sgp_read_cmd(data, SGP_CMD_GET_FEATURE_SET, &data->buffer, 1,
525 SGP_CMD_DURATION_US);
526 if (ret < 0)
527 return ret;
528
529 data->feature_set = be16_to_cpu(data->buffer.raw_words[0].value);
530
531 ret = sgp_check_compat(data, match_data->product_id);
532 if (ret)
533 return ret;
534
535 indio_dev->info = &sgp_info;
536 indio_dev->name = id->name;
537 indio_dev->modes = INDIO_DIRECT_MODE;
538 indio_dev->channels = match_data->channels;
539 indio_dev->num_channels = match_data->num_channels;
540
541 sgp_init(data);
542
543 ret = devm_iio_device_register(dev, indio_dev);
544 if (ret) {
545 dev_err(dev, "failed to register iio device\n");
546 return ret;
547 }
548
549 data->iaq_thread = kthread_run(sgp_iaq_threadfn, data,
550 "%s-iaq", data->client->name);
551 if (IS_ERR(data->iaq_thread))
552 return dev_err_probe(dev, PTR_ERR(data->iaq_thread),
553 "failed to start IAQ thread\n");
554
555 return 0;
556 }
557
sgp_remove(struct i2c_client * client)558 static void sgp_remove(struct i2c_client *client)
559 {
560 struct iio_dev *indio_dev = i2c_get_clientdata(client);
561 struct sgp_data *data = iio_priv(indio_dev);
562
563 if (data->iaq_thread)
564 kthread_stop(data->iaq_thread);
565 }
566
567 static const struct i2c_device_id sgp_id[] = {
568 { .name = "sgp30", .driver_data = (kernel_ulong_t)&sgp_devices[SGP30] },
569 { .name = "sgpc3", .driver_data = (kernel_ulong_t)&sgp_devices[SGPC3] },
570 { }
571 };
572 MODULE_DEVICE_TABLE(i2c, sgp_id);
573
574 static struct i2c_driver sgp_driver = {
575 .driver = {
576 .name = "sgp30",
577 .of_match_table = sgp_dt_ids,
578 },
579 .probe = sgp_probe,
580 .remove = sgp_remove,
581 .id_table = sgp_id,
582 };
583 module_i2c_driver(sgp_driver);
584
585 MODULE_AUTHOR("Andreas Brauchli <andreas.brauchli@sensirion.com>");
586 MODULE_AUTHOR("Pascal Sachs <pascal.sachs@sensirion.com>");
587 MODULE_DESCRIPTION("Sensirion SGP gas sensors");
588 MODULE_LICENSE("GPL v2");
589