?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge tag 'block-5.11-2021-01-10' of git://git.kernel.dk/linux-block
[linux/fpc-iii.git] / drivers / iio / chemical / sgp30.c
blob1029c457be15046c5d5bfefd2a95aef2a59718e6
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/mod_devicetable.h>
24 #include <linux/mutex.h>
25 #include <linux/i2c.h>
26 #include <linux/iio/iio.h>
27 #include <linux/iio/sysfs.h>
28
29 #define SGP_WORD_LEN 2
30 #define SGP_CRC8_POLYNOMIAL 0x31
31 #define SGP_CRC8_INIT 0xff
32 #define SGP_CRC8_LEN 1
33 #define SGP_CMD(cmd_word) cpu_to_be16(cmd_word)
34 #define SGP_CMD_DURATION_US 12000
35 #define SGP_MEASUREMENT_DURATION_US 50000
36 #define SGP_CMD_LEN SGP_WORD_LEN
37 #define SGP_CMD_MAX_BUF_SIZE (SGP_CMD_LEN + 2 * SGP_WORD_LEN)
38 #define SGP_MEASUREMENT_LEN 2
39 #define SGP30_MEASURE_INTERVAL_HZ 1
40 #define SGPC3_MEASURE_INTERVAL_HZ 2
41 #define SGP_VERS_PRODUCT(data) ((((data)->feature_set) & 0xf000) >> 12)
42 #define SGP_VERS_RESERVED(data) ((((data)->feature_set) & 0x0800) >> 11)
43 #define SGP_VERS_GEN(data) ((((data)->feature_set) & 0x0600) >> 9)
44 #define SGP_VERS_ENG_BIT(data) ((((data)->feature_set) & 0x0100) >> 8)
45 #define SGP_VERS_MAJOR(data) ((((data)->feature_set) & 0x00e0) >> 5)
46 #define SGP_VERS_MINOR(data) (((data)->feature_set) & 0x001f)
47
48 DECLARE_CRC8_TABLE(sgp_crc8_table);
49
50 enum sgp_product_id {
51 SGP30 = 0,
52 SGPC3,
53 };
54
55 enum sgp30_channel_idx {
56 SGP30_IAQ_TVOC_IDX = 0,
57 SGP30_IAQ_CO2EQ_IDX,
58 SGP30_SIG_ETOH_IDX,
59 SGP30_SIG_H2_IDX,
60 };
61
62 enum sgpc3_channel_idx {
63 SGPC3_IAQ_TVOC_IDX = 10,
64 SGPC3_SIG_ETOH_IDX,
65 };
66
67 enum sgp_cmd {
68 SGP_CMD_IAQ_INIT = SGP_CMD(0x2003),
69 SGP_CMD_IAQ_MEASURE = SGP_CMD(0x2008),
70 SGP_CMD_GET_FEATURE_SET = SGP_CMD(0x202f),
71 SGP_CMD_GET_SERIAL_ID = SGP_CMD(0x3682),
72
73 SGP30_CMD_MEASURE_SIGNAL = SGP_CMD(0x2050),
74
75 SGPC3_CMD_MEASURE_RAW = SGP_CMD(0x2046),
76 };
77
78 struct sgp_version {
79 u8 major;
80 u8 minor;
81 };
82
83 struct sgp_crc_word {
84 __be16 value;
85 u8 crc8;
86 } __attribute__((__packed__));
87
88 union sgp_reading {
89 u8 start;
90 struct sgp_crc_word raw_words[4];
91 };
92
93 enum _iaq_buffer_state {
94 IAQ_BUFFER_EMPTY = 0,
95 IAQ_BUFFER_DEFAULT_VALS,
96 IAQ_BUFFER_VALID,
97 };
98
99 struct sgp_data {
100 struct i2c_client *client;
101 struct task_struct *iaq_thread;
102 struct mutex data_lock;
103 unsigned long iaq_init_start_jiffies;
104 unsigned long iaq_defval_skip_jiffies;
105 u16 product_id;
106 u16 feature_set;
107 unsigned long measure_interval_jiffies;
108 enum sgp_cmd iaq_init_cmd;
109 enum sgp_cmd measure_iaq_cmd;
110 enum sgp_cmd measure_gas_signals_cmd;
111 union sgp_reading buffer;
112 union sgp_reading iaq_buffer;
113 enum _iaq_buffer_state iaq_buffer_state;
114 };
115
116 struct sgp_device {
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 .channels = sgp30_channels,
186 .num_channels = ARRAY_SIZE(sgp30_channels),
187 },
188 [SGPC3] = {
189 .channels = sgpc3_channels,
190 .num_channels = ARRAY_SIZE(sgpc3_channels),
191 },
192 };
193
194 /**
195 * sgp_verify_buffer() - verify the checksums of the data buffer words
196 *
197 * @data: SGP data
198 * @buf: Raw data buffer
199 * @word_count: Num data words stored in the buffer, excluding CRC bytes
200 *
201 * Return: 0 on success, negative error otherwise.
202 */
203 static int sgp_verify_buffer(const struct sgp_data *data,
204 union sgp_reading *buf, size_t word_count)
205 {
206 size_t size = word_count * (SGP_WORD_LEN + SGP_CRC8_LEN);
207 int i;
208 u8 crc;
209 u8 *data_buf = &buf->start;
210
211 for (i = 0; i < size; i += SGP_WORD_LEN + SGP_CRC8_LEN) {
212 crc = crc8(sgp_crc8_table, &data_buf[i], SGP_WORD_LEN,
213 SGP_CRC8_INIT);
214 if (crc != data_buf[i + SGP_WORD_LEN]) {
215 dev_err(&data->client->dev, "CRC error\n");
216 return -EIO;
217 }
218 }
219
220 return 0;
221 }
222
223 /**
224 * sgp_read_cmd() - reads data from sensor after issuing a command
225 * The caller must hold data->data_lock for the duration of the call.
226 * @data: SGP data
227 * @cmd: SGP Command to issue
228 * @buf: Raw data buffer to use
229 * @word_count: Num words to read, excluding CRC bytes
230 * @duration_us: Time taken to sensor to take a reading and data to be ready.
231 *
232 * Return: 0 on success, negative error otherwise.
233 */
234 static int sgp_read_cmd(struct sgp_data *data, enum sgp_cmd cmd,
235 union sgp_reading *buf, size_t word_count,
236 unsigned long duration_us)
237 {
238 int ret;
239 struct i2c_client *client = data->client;
240 size_t size = word_count * (SGP_WORD_LEN + SGP_CRC8_LEN);
241 u8 *data_buf;
242
243 ret = i2c_master_send(client, (const char *)&cmd, SGP_CMD_LEN);
244 if (ret != SGP_CMD_LEN)
245 return -EIO;
246 usleep_range(duration_us, duration_us + 1000);
247
248 if (word_count == 0)
249 return 0;
250
251 data_buf = &buf->start;
252 ret = i2c_master_recv(client, data_buf, size);
253 if (ret < 0)
254 return ret;
255 if (ret != size)
256 return -EIO;
257
258 return sgp_verify_buffer(data, buf, word_count);
259 }
260
261 /**
262 * sgp_measure_iaq() - measure and retrieve IAQ values from sensor
263 * The caller must hold data->data_lock for the duration of the call.
264 * @data: SGP data
265 *
266 * Return: 0 on success, -EBUSY on default values, negative error
267 * otherwise.
268 */
269
270 static int sgp_measure_iaq(struct sgp_data *data)
271 {
272 int ret;
273 /* data contains default values */
274 bool default_vals = !time_after(jiffies, data->iaq_init_start_jiffies +
275 data->iaq_defval_skip_jiffies);
276
277 ret = sgp_read_cmd(data, data->measure_iaq_cmd, &data->iaq_buffer,
278 SGP_MEASUREMENT_LEN, SGP_MEASUREMENT_DURATION_US);
279 if (ret < 0)
280 return ret;
281
282 data->iaq_buffer_state = IAQ_BUFFER_DEFAULT_VALS;
283
284 if (default_vals)
285 return -EBUSY;
286
287 data->iaq_buffer_state = IAQ_BUFFER_VALID;
288
289 return 0;
290 }
291
292 static void sgp_iaq_thread_sleep_until(const struct sgp_data *data,
293 unsigned long sleep_jiffies)
294 {
295 const long IAQ_POLL = 50000;
296
297 while (!time_after(jiffies, sleep_jiffies)) {
298 usleep_range(IAQ_POLL, IAQ_POLL + 10000);
299 if (kthread_should_stop() || data->iaq_init_start_jiffies == 0)
300 return;
301 }
302 }
303
304 static int sgp_iaq_threadfn(void *p)
305 {
306 struct sgp_data *data = (struct sgp_data *)p;
307 unsigned long next_update_jiffies;
308 int ret;
309
310 while (!kthread_should_stop()) {
311 mutex_lock(&data->data_lock);
312 if (data->iaq_init_start_jiffies == 0) {
313 ret = sgp_read_cmd(data, data->iaq_init_cmd, NULL, 0,
314 SGP_CMD_DURATION_US);
315 if (ret < 0)
316 goto unlock_sleep_continue;
317 data->iaq_init_start_jiffies = jiffies;
318 }
319
320 ret = sgp_measure_iaq(data);
321 if (ret && ret != -EBUSY) {
322 dev_warn(&data->client->dev,
323 "IAQ measurement error [%d]\n", ret);
324 }
325 unlock_sleep_continue:
326 next_update_jiffies = jiffies + data->measure_interval_jiffies;
327 mutex_unlock(&data->data_lock);
328 sgp_iaq_thread_sleep_until(data, next_update_jiffies);
329 }
330
331 return 0;
332 }
333
334 static int sgp_read_raw(struct iio_dev *indio_dev,
335 struct iio_chan_spec const *chan, int *val,
336 int *val2, long mask)
337 {
338 struct sgp_data *data = iio_priv(indio_dev);
339 struct sgp_crc_word *words;
340 int ret;
341
342 switch (mask) {
343 case IIO_CHAN_INFO_PROCESSED:
344 mutex_lock(&data->data_lock);
345 if (data->iaq_buffer_state != IAQ_BUFFER_VALID) {
346 mutex_unlock(&data->data_lock);
347 return -EBUSY;
348 }
349 words = data->iaq_buffer.raw_words;
350 switch (chan->address) {
351 case SGP30_IAQ_TVOC_IDX:
352 case SGPC3_IAQ_TVOC_IDX:
353 *val = 0;
354 *val2 = be16_to_cpu(words[1].value);
355 ret = IIO_VAL_INT_PLUS_NANO;
356 break;
357 case SGP30_IAQ_CO2EQ_IDX:
358 *val = 0;
359 *val2 = be16_to_cpu(words[0].value);
360 ret = IIO_VAL_INT_PLUS_MICRO;
361 break;
362 default:
363 ret = -EINVAL;
364 break;
365 }
366 mutex_unlock(&data->data_lock);
367 break;
368 case IIO_CHAN_INFO_RAW:
369 mutex_lock(&data->data_lock);
370 if (chan->address == SGPC3_SIG_ETOH_IDX) {
371 if (data->iaq_buffer_state == IAQ_BUFFER_EMPTY)
372 ret = -EBUSY;
373 else
374 ret = 0;
375 words = data->iaq_buffer.raw_words;
376 } else {
377 ret = sgp_read_cmd(data, data->measure_gas_signals_cmd,
378 &data->buffer, SGP_MEASUREMENT_LEN,
379 SGP_MEASUREMENT_DURATION_US);
380 words = data->buffer.raw_words;
381 }
382 if (ret) {
383 mutex_unlock(&data->data_lock);
384 return ret;
385 }
386
387 switch (chan->address) {
388 case SGP30_SIG_ETOH_IDX:
389 *val = be16_to_cpu(words[1].value);
390 ret = IIO_VAL_INT;
391 break;
392 case SGPC3_SIG_ETOH_IDX:
393 case SGP30_SIG_H2_IDX:
394 *val = be16_to_cpu(words[0].value);
395 ret = IIO_VAL_INT;
396 break;
397 default:
398 ret = -EINVAL;
399 break;
400 }
401 mutex_unlock(&data->data_lock);
402 break;
403 default:
404 return -EINVAL;
405 }
406
407 return ret;
408 }
409
410 static int sgp_check_compat(struct sgp_data *data,
411 unsigned int product_id)
412 {
413 struct device *dev = &data->client->dev;
414 const struct sgp_version *supported_versions;
415 u16 ix, num_fs;
416 u16 product, generation, major, minor;
417
418 /* driver does not match product */
419 generation = SGP_VERS_GEN(data);
420 if (generation != 0) {
421 dev_err(dev,
422 "incompatible product generation %d != 0", generation);
423 return -ENODEV;
424 }
425
426 product = SGP_VERS_PRODUCT(data);
427 if (product != product_id) {
428 dev_err(dev, "sensor reports a different product: 0x%04hx\n",
429 product);
430 return -ENODEV;
431 }
432
433 if (SGP_VERS_RESERVED(data))
434 dev_warn(dev, "reserved bit is set\n");
435
436 /* engineering samples are not supported: no interface guarantees */
437 if (SGP_VERS_ENG_BIT(data))
438 return -ENODEV;
439
440 switch (product) {
441 case SGP30:
442 supported_versions = supported_versions_sgp30;
443 num_fs = ARRAY_SIZE(supported_versions_sgp30);
444 break;
445 case SGPC3:
446 supported_versions = supported_versions_sgpc3;
447 num_fs = ARRAY_SIZE(supported_versions_sgpc3);
448 break;
449 default:
450 return -ENODEV;
451 }
452
453 major = SGP_VERS_MAJOR(data);
454 minor = SGP_VERS_MINOR(data);
455 for (ix = 0; ix < num_fs; ix++) {
456 if (major == supported_versions[ix].major &&
457 minor >= supported_versions[ix].minor)
458 return 0;
459 }
460 dev_err(dev, "unsupported sgp version: %d.%d\n", major, minor);
461
462 return -ENODEV;
463 }
464
465 static void sgp_init(struct sgp_data *data)
466 {
467 data->iaq_init_cmd = SGP_CMD_IAQ_INIT;
468 data->iaq_init_start_jiffies = 0;
469 data->iaq_buffer_state = IAQ_BUFFER_EMPTY;
470 switch (SGP_VERS_PRODUCT(data)) {
471 case SGP30:
472 data->measure_interval_jiffies = SGP30_MEASURE_INTERVAL_HZ * HZ;
473 data->measure_iaq_cmd = SGP_CMD_IAQ_MEASURE;
474 data->measure_gas_signals_cmd = SGP30_CMD_MEASURE_SIGNAL;
475 data->product_id = SGP30;
476 data->iaq_defval_skip_jiffies = 15 * HZ;
477 break;
478 case SGPC3:
479 data->measure_interval_jiffies = SGPC3_MEASURE_INTERVAL_HZ * HZ;
480 data->measure_iaq_cmd = SGPC3_CMD_MEASURE_RAW;
481 data->measure_gas_signals_cmd = SGPC3_CMD_MEASURE_RAW;
482 data->product_id = SGPC3;
483 data->iaq_defval_skip_jiffies =
484 43 * data->measure_interval_jiffies;
485 break;
486 }
487 }
488
489 static const struct iio_info sgp_info = {
490 .read_raw = sgp_read_raw,
491 };
492
493 static const struct of_device_id sgp_dt_ids[] = {
494 { .compatible = "sensirion,sgp30", .data = (void *)SGP30 },
495 { .compatible = "sensirion,sgpc3", .data = (void *)SGPC3 },
496 { }
497 };
498
499 static int sgp_probe(struct i2c_client *client,
500 const struct i2c_device_id *id)
501 {
502 struct device *dev = &client->dev;
503 struct iio_dev *indio_dev;
504 struct sgp_data *data;
505 unsigned long product_id;
506 int ret;
507
508 indio_dev = devm_iio_device_alloc(dev, sizeof(*data));
509 if (!indio_dev)
510 return -ENOMEM;
511
512 if (dev_fwnode(dev))
513 product_id = (unsigned long)device_get_match_data(dev);
514 else
515 product_id = id->driver_data;
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, 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 = sgp_devices[product_id].channels;
539 indio_dev->num_channels = sgp_devices[product_id].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
552 return 0;
553 }
554
555 static int sgp_remove(struct i2c_client *client)
556 {
557 struct iio_dev *indio_dev = i2c_get_clientdata(client);
558 struct sgp_data *data = iio_priv(indio_dev);
559
560 if (data->iaq_thread)
561 kthread_stop(data->iaq_thread);
562
563 return 0;
564 }
565
566 static const struct i2c_device_id sgp_id[] = {
567 { "sgp30", SGP30 },
568 { "sgpc3", SGPC3 },
569 { }
570 };
571
572 MODULE_DEVICE_TABLE(i2c, sgp_id);
573 MODULE_DEVICE_TABLE(of, sgp_dt_ids);
574
575 static struct i2c_driver sgp_driver = {
576 .driver = {
577 .name = "sgp30",
578 .of_match_table = sgp_dt_ids,
579 },
580 .probe = sgp_probe,
581 .remove = sgp_remove,
582 .id_table = sgp_id,
583 };
584 module_i2c_driver(sgp_driver);
585
586 MODULE_AUTHOR("Andreas Brauchli <andreas.brauchli@sensirion.com>");
587 MODULE_AUTHOR("Pascal Sachs <pascal.sachs@sensirion.com>");
588 MODULE_DESCRIPTION("Sensirion SGP gas sensors");
589 MODULE_LICENSE("GPL v2");
Linux with added FPC-III support