1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * Sensirion SCD4X carbon dioxide sensor i2c driver
4 *
5 * Copyright (C) 2021 Protonic Holland
6 * Author: Roan van Dijk <roan@protonic.nl>
7 *
8 * I2C slave address: 0x62
9 *
10 * Datasheets:
11 * https://www.sensirion.com/file/datasheet_scd4x
12 */
13
14 #include <asm/unaligned.h>
15 #include <linux/crc8.h>
16 #include <linux/delay.h>
17 #include <linux/device.h>
18 #include <linux/i2c.h>
19 #include <linux/iio/buffer.h>
20 #include <linux/iio/iio.h>
21 #include <linux/iio/sysfs.h>
22 #include <linux/iio/trigger.h>
23 #include <linux/iio/trigger_consumer.h>
24 #include <linux/iio/triggered_buffer.h>
25 #include <linux/iio/types.h>
26 #include <linux/kernel.h>
27 #include <linux/mutex.h>
28 #include <linux/string.h>
29 #include <linux/sysfs.h>
30 #include <linux/types.h>
31
32 #define SCD4X_CRC8_POLYNOMIAL 0x31
33 #define SCD4X_TIMEOUT_ERR 1000
34 #define SCD4X_READ_BUF_SIZE 9
35 #define SCD4X_COMMAND_BUF_SIZE 2
36 #define SCD4X_WRITE_BUF_SIZE 5
37 #define SCD4X_FRC_MIN_PPM 0
38 #define SCD4X_FRC_MAX_PPM 2000
39 #define SCD4X_READY_MASK 0x01
40
41 /*Commands SCD4X*/
42 enum scd4x_cmd {
43 CMD_START_MEAS = 0x21b1,
44 CMD_READ_MEAS = 0xec05,
45 CMD_STOP_MEAS = 0x3f86,
46 CMD_SET_TEMP_OFFSET = 0x241d,
47 CMD_GET_TEMP_OFFSET = 0x2318,
48 CMD_FRC = 0x362f,
49 CMD_SET_ASC = 0x2416,
50 CMD_GET_ASC = 0x2313,
51 CMD_GET_DATA_READY = 0xe4b8,
52 };
53
54 enum scd4x_channel_idx {
55 SCD4X_CO2,
56 SCD4X_TEMP,
57 SCD4X_HR,
58 };
59
60 struct scd4x_state {
61 struct i2c_client *client;
62 /* maintain access to device, to prevent concurrent reads/writes */
63 struct mutex lock;
64 struct regulator *vdd;
65 };
66
67 DECLARE_CRC8_TABLE(scd4x_crc8_table);
68
scd4x_i2c_xfer(struct scd4x_state * state,char * txbuf,int txsize,char * rxbuf,int rxsize)69 static int scd4x_i2c_xfer(struct scd4x_state *state, char *txbuf, int txsize,
70 char *rxbuf, int rxsize)
71 {
72 struct i2c_client *client = state->client;
73 int ret;
74
75 ret = i2c_master_send(client, txbuf, txsize);
76
77 if (ret < 0)
78 return ret;
79 if (ret != txsize)
80 return -EIO;
81
82 if (rxsize == 0)
83 return 0;
84
85 ret = i2c_master_recv(client, rxbuf, rxsize);
86 if (ret < 0)
87 return ret;
88 if (ret != rxsize)
89 return -EIO;
90
91 return 0;
92 }
93
scd4x_send_command(struct scd4x_state * state,enum scd4x_cmd cmd)94 static int scd4x_send_command(struct scd4x_state *state, enum scd4x_cmd cmd)
95 {
96 char buf[SCD4X_COMMAND_BUF_SIZE];
97 int ret;
98
99 /*
100 * Measurement needs to be stopped before sending commands.
101 * Except stop and start command.
102 */
103 if ((cmd != CMD_STOP_MEAS) && (cmd != CMD_START_MEAS)) {
104
105 ret = scd4x_send_command(state, CMD_STOP_MEAS);
106 if (ret)
107 return ret;
108
109 /* execution time for stopping measurement */
110 msleep_interruptible(500);
111 }
112
113 put_unaligned_be16(cmd, buf);
114 ret = scd4x_i2c_xfer(state, buf, 2, buf, 0);
115 if (ret)
116 return ret;
117
118 if ((cmd != CMD_STOP_MEAS) && (cmd != CMD_START_MEAS)) {
119 ret = scd4x_send_command(state, CMD_START_MEAS);
120 if (ret)
121 return ret;
122 }
123
124 return 0;
125 }
126
scd4x_read(struct scd4x_state * state,enum scd4x_cmd cmd,void * response,int response_sz)127 static int scd4x_read(struct scd4x_state *state, enum scd4x_cmd cmd,
128 void *response, int response_sz)
129 {
130 struct i2c_client *client = state->client;
131 char buf[SCD4X_READ_BUF_SIZE];
132 char *rsp = response;
133 int i, ret;
134 char crc;
135
136 /*
137 * Measurement needs to be stopped before sending commands.
138 * Except for reading measurement and data ready command.
139 */
140 if ((cmd != CMD_GET_DATA_READY) && (cmd != CMD_READ_MEAS)) {
141 ret = scd4x_send_command(state, CMD_STOP_MEAS);
142 if (ret)
143 return ret;
144
145 /* execution time for stopping measurement */
146 msleep_interruptible(500);
147 }
148
149 /* CRC byte for every 2 bytes of data */
150 response_sz += response_sz / 2;
151
152 put_unaligned_be16(cmd, buf);
153 ret = scd4x_i2c_xfer(state, buf, 2, buf, response_sz);
154 if (ret)
155 return ret;
156
157 for (i = 0; i < response_sz; i += 3) {
158 crc = crc8(scd4x_crc8_table, buf + i, 2, CRC8_INIT_VALUE);
159 if (crc != buf[i + 2]) {
160 dev_err(&client->dev, "CRC error\n");
161 return -EIO;
162 }
163
164 *rsp++ = buf[i];
165 *rsp++ = buf[i + 1];
166 }
167
168 /* start measurement */
169 if ((cmd != CMD_GET_DATA_READY) && (cmd != CMD_READ_MEAS)) {
170 ret = scd4x_send_command(state, CMD_START_MEAS);
171 if (ret)
172 return ret;
173 }
174
175 return 0;
176 }
177
scd4x_write(struct scd4x_state * state,enum scd4x_cmd cmd,uint16_t arg)178 static int scd4x_write(struct scd4x_state *state, enum scd4x_cmd cmd, uint16_t arg)
179 {
180 char buf[SCD4X_WRITE_BUF_SIZE];
181 int ret;
182 char crc;
183
184 put_unaligned_be16(cmd, buf);
185 put_unaligned_be16(arg, buf + 2);
186
187 crc = crc8(scd4x_crc8_table, buf + 2, 2, CRC8_INIT_VALUE);
188 buf[4] = crc;
189
190 /* measurement needs to be stopped before sending commands */
191 ret = scd4x_send_command(state, CMD_STOP_MEAS);
192 if (ret)
193 return ret;
194
195 /* execution time */
196 msleep_interruptible(500);
197
198 ret = scd4x_i2c_xfer(state, buf, SCD4X_WRITE_BUF_SIZE, buf, 0);
199 if (ret)
200 return ret;
201
202 /* start measurement, except for forced calibration command */
203 if (cmd != CMD_FRC) {
204 ret = scd4x_send_command(state, CMD_START_MEAS);
205 if (ret)
206 return ret;
207 }
208
209 return 0;
210 }
211
scd4x_write_and_fetch(struct scd4x_state * state,enum scd4x_cmd cmd,uint16_t arg,void * response,int response_sz)212 static int scd4x_write_and_fetch(struct scd4x_state *state, enum scd4x_cmd cmd,
213 uint16_t arg, void *response, int response_sz)
214 {
215 struct i2c_client *client = state->client;
216 char buf[SCD4X_READ_BUF_SIZE];
217 char *rsp = response;
218 int i, ret;
219 char crc;
220
221 ret = scd4x_write(state, CMD_FRC, arg);
222 if (ret)
223 goto err;
224
225 /* execution time */
226 msleep_interruptible(400);
227
228 /* CRC byte for every 2 bytes of data */
229 response_sz += response_sz / 2;
230
231 ret = i2c_master_recv(client, buf, response_sz);
232 if (ret < 0)
233 goto err;
234 if (ret != response_sz) {
235 ret = -EIO;
236 goto err;
237 }
238
239 for (i = 0; i < response_sz; i += 3) {
240 crc = crc8(scd4x_crc8_table, buf + i, 2, CRC8_INIT_VALUE);
241 if (crc != buf[i + 2]) {
242 dev_err(&client->dev, "CRC error\n");
243 ret = -EIO;
244 goto err;
245 }
246
247 *rsp++ = buf[i];
248 *rsp++ = buf[i + 1];
249 }
250
251 return scd4x_send_command(state, CMD_START_MEAS);
252
253 err:
254 /*
255 * on error try to start the measurement,
256 * puts sensor back into continuous measurement
257 */
258 scd4x_send_command(state, CMD_START_MEAS);
259
260 return ret;
261 }
262
scd4x_read_meas(struct scd4x_state * state,uint16_t * meas)263 static int scd4x_read_meas(struct scd4x_state *state, uint16_t *meas)
264 {
265 int i, ret;
266 __be16 buf[3];
267
268 ret = scd4x_read(state, CMD_READ_MEAS, buf, sizeof(buf));
269 if (ret)
270 return ret;
271
272 for (i = 0; i < ARRAY_SIZE(buf); i++)
273 meas[i] = be16_to_cpu(buf[i]);
274
275 return 0;
276 }
277
scd4x_wait_meas_poll(struct scd4x_state * state)278 static int scd4x_wait_meas_poll(struct scd4x_state *state)
279 {
280 struct i2c_client *client = state->client;
281 int tries = 6;
282 int ret;
283
284 do {
285 __be16 bval;
286 uint16_t val;
287
288 ret = scd4x_read(state, CMD_GET_DATA_READY, &bval, sizeof(bval));
289 if (ret)
290 return -EIO;
291 val = be16_to_cpu(bval);
292
293 /* new measurement available */
294 if (val & 0x7FF)
295 return 0;
296
297 msleep_interruptible(1000);
298 } while (--tries);
299
300 /* try to start sensor on timeout */
301 ret = scd4x_send_command(state, CMD_START_MEAS);
302 if (ret)
303 dev_err(&client->dev, "failed to start measurement: %d\n", ret);
304
305 return -ETIMEDOUT;
306 }
307
scd4x_read_poll(struct scd4x_state * state,uint16_t * buf)308 static int scd4x_read_poll(struct scd4x_state *state, uint16_t *buf)
309 {
310 int ret;
311
312 ret = scd4x_wait_meas_poll(state);
313 if (ret)
314 return ret;
315
316 return scd4x_read_meas(state, buf);
317 }
318
scd4x_read_channel(struct scd4x_state * state,int chan)319 static int scd4x_read_channel(struct scd4x_state *state, int chan)
320 {
321 int ret;
322 uint16_t buf[3];
323
324 ret = scd4x_read_poll(state, buf);
325 if (ret)
326 return ret;
327
328 return buf[chan];
329 }
330
scd4x_read_raw(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,int * val,int * val2,long mask)331 static int scd4x_read_raw(struct iio_dev *indio_dev,
332 struct iio_chan_spec const *chan, int *val,
333 int *val2, long mask)
334 {
335 struct scd4x_state *state = iio_priv(indio_dev);
336 int ret;
337 __be16 tmp;
338
339 switch (mask) {
340 case IIO_CHAN_INFO_RAW:
341 ret = iio_device_claim_direct_mode(indio_dev);
342 if (ret)
343 return ret;
344
345 mutex_lock(&state->lock);
346 ret = scd4x_read_channel(state, chan->address);
347 mutex_unlock(&state->lock);
348
349 iio_device_release_direct_mode(indio_dev);
350 if (ret < 0)
351 return ret;
352
353 *val = ret;
354 return IIO_VAL_INT;
355 case IIO_CHAN_INFO_SCALE:
356 if (chan->type == IIO_CONCENTRATION) {
357 *val = 0;
358 *val2 = 100;
359 return IIO_VAL_INT_PLUS_MICRO;
360 } else if (chan->type == IIO_TEMP) {
361 *val = 175000;
362 *val2 = 65536;
363 return IIO_VAL_FRACTIONAL;
364 } else if (chan->type == IIO_HUMIDITYRELATIVE) {
365 *val = 100000;
366 *val2 = 65536;
367 return IIO_VAL_FRACTIONAL;
368 }
369 return -EINVAL;
370 case IIO_CHAN_INFO_OFFSET:
371 *val = -16852;
372 *val2 = 114286;
373 return IIO_VAL_INT_PLUS_MICRO;
374 case IIO_CHAN_INFO_CALIBBIAS:
375 mutex_lock(&state->lock);
376 ret = scd4x_read(state, CMD_GET_TEMP_OFFSET, &tmp, sizeof(tmp));
377 mutex_unlock(&state->lock);
378 if (ret)
379 return ret;
380
381 *val = be16_to_cpu(tmp);
382
383 return IIO_VAL_INT;
384 default:
385 return -EINVAL;
386 }
387 }
388
scd4x_write_raw(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,int val,int val2,long mask)389 static int scd4x_write_raw(struct iio_dev *indio_dev, struct iio_chan_spec const *chan,
390 int val, int val2, long mask)
391 {
392 struct scd4x_state *state = iio_priv(indio_dev);
393 int ret = 0;
394
395 switch (mask) {
396 case IIO_CHAN_INFO_CALIBBIAS:
397 mutex_lock(&state->lock);
398 ret = scd4x_write(state, CMD_SET_TEMP_OFFSET, val);
399 mutex_unlock(&state->lock);
400
401 return ret;
402 default:
403 return -EINVAL;
404 }
405 }
406
calibration_auto_enable_show(struct device * dev,struct device_attribute * attr,char * buf)407 static ssize_t calibration_auto_enable_show(struct device *dev,
408 struct device_attribute *attr, char *buf)
409 {
410 struct iio_dev *indio_dev = dev_to_iio_dev(dev);
411 struct scd4x_state *state = iio_priv(indio_dev);
412 int ret;
413 __be16 bval;
414 u16 val;
415
416 mutex_lock(&state->lock);
417 ret = scd4x_read(state, CMD_GET_ASC, &bval, sizeof(bval));
418 mutex_unlock(&state->lock);
419 if (ret) {
420 dev_err(dev, "failed to read automatic calibration");
421 return ret;
422 }
423
424 val = (be16_to_cpu(bval) & SCD4X_READY_MASK) ? 1 : 0;
425
426 return sysfs_emit(buf, "%d\n", val);
427 }
428
calibration_auto_enable_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t len)429 static ssize_t calibration_auto_enable_store(struct device *dev,
430 struct device_attribute *attr,
431 const char *buf, size_t len)
432 {
433 struct iio_dev *indio_dev = dev_to_iio_dev(dev);
434 struct scd4x_state *state = iio_priv(indio_dev);
435 bool val;
436 int ret;
437 uint16_t value;
438
439 ret = kstrtobool(buf, &val);
440 if (ret)
441 return ret;
442
443 value = val;
444
445 mutex_lock(&state->lock);
446 ret = scd4x_write(state, CMD_SET_ASC, value);
447 mutex_unlock(&state->lock);
448 if (ret)
449 dev_err(dev, "failed to set automatic calibration");
450
451 return ret ?: len;
452 }
453
calibration_forced_value_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t len)454 static ssize_t calibration_forced_value_store(struct device *dev,
455 struct device_attribute *attr,
456 const char *buf, size_t len)
457 {
458 struct iio_dev *indio_dev = dev_to_iio_dev(dev);
459 struct scd4x_state *state = iio_priv(indio_dev);
460 uint16_t val, arg;
461 int ret;
462
463 ret = kstrtou16(buf, 0, &arg);
464 if (ret)
465 return ret;
466
467 if (arg < SCD4X_FRC_MIN_PPM || arg > SCD4X_FRC_MAX_PPM)
468 return -EINVAL;
469
470 mutex_lock(&state->lock);
471 ret = scd4x_write_and_fetch(state, CMD_FRC, arg, &val, sizeof(val));
472 mutex_unlock(&state->lock);
473
474 if (ret)
475 return ret;
476
477 if (val == 0xff) {
478 dev_err(dev, "forced calibration has failed");
479 return -EINVAL;
480 }
481
482 return len;
483 }
484
485 static IIO_DEVICE_ATTR_RW(calibration_auto_enable, 0);
486 static IIO_DEVICE_ATTR_WO(calibration_forced_value, 0);
487
488 static IIO_CONST_ATTR(calibration_forced_value_available,
489 __stringify([SCD4X_FRC_MIN_PPM 1 SCD4X_FRC_MAX_PPM]));
490
491 static struct attribute *scd4x_attrs[] = {
492 &iio_dev_attr_calibration_auto_enable.dev_attr.attr,
493 &iio_dev_attr_calibration_forced_value.dev_attr.attr,
494 &iio_const_attr_calibration_forced_value_available.dev_attr.attr,
495 NULL
496 };
497
498 static const struct attribute_group scd4x_attr_group = {
499 .attrs = scd4x_attrs,
500 };
501
502 static const struct iio_info scd4x_info = {
503 .attrs = &scd4x_attr_group,
504 .read_raw = scd4x_read_raw,
505 .write_raw = scd4x_write_raw,
506 };
507
508 static const struct iio_chan_spec scd4x_channels[] = {
509 {
510 .type = IIO_CONCENTRATION,
511 .channel2 = IIO_MOD_CO2,
512 .modified = 1,
513 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
514 BIT(IIO_CHAN_INFO_SCALE),
515 .address = SCD4X_CO2,
516 .scan_index = SCD4X_CO2,
517 .scan_type = {
518 .sign = 'u',
519 .realbits = 16,
520 .storagebits = 16,
521 .endianness = IIO_BE,
522 },
523 },
524 {
525 .type = IIO_TEMP,
526 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
527 BIT(IIO_CHAN_INFO_SCALE) |
528 BIT(IIO_CHAN_INFO_OFFSET) |
529 BIT(IIO_CHAN_INFO_CALIBBIAS),
530 .address = SCD4X_TEMP,
531 .scan_index = SCD4X_TEMP,
532 .scan_type = {
533 .sign = 'u',
534 .realbits = 16,
535 .storagebits = 16,
536 .endianness = IIO_BE,
537 },
538 },
539 {
540 .type = IIO_HUMIDITYRELATIVE,
541 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
542 BIT(IIO_CHAN_INFO_SCALE),
543 .address = SCD4X_HR,
544 .scan_index = SCD4X_HR,
545 .scan_type = {
546 .sign = 'u',
547 .realbits = 16,
548 .storagebits = 16,
549 .endianness = IIO_BE,
550 },
551 },
552 };
553
scd4x_suspend(struct device * dev)554 static int scd4x_suspend(struct device *dev)
555 {
556 struct iio_dev *indio_dev = dev_get_drvdata(dev);
557 struct scd4x_state *state = iio_priv(indio_dev);
558 int ret;
559
560 ret = scd4x_send_command(state, CMD_STOP_MEAS);
561 if (ret)
562 return ret;
563
564 return regulator_disable(state->vdd);
565 }
566
scd4x_resume(struct device * dev)567 static int scd4x_resume(struct device *dev)
568 {
569 struct iio_dev *indio_dev = dev_get_drvdata(dev);
570 struct scd4x_state *state = iio_priv(indio_dev);
571 int ret;
572
573 ret = regulator_enable(state->vdd);
574 if (ret)
575 return ret;
576
577 return scd4x_send_command(state, CMD_START_MEAS);
578 }
579
580 static DEFINE_SIMPLE_DEV_PM_OPS(scd4x_pm_ops, scd4x_suspend, scd4x_resume);
581
scd4x_stop_meas(void * state)582 static void scd4x_stop_meas(void *state)
583 {
584 scd4x_send_command(state, CMD_STOP_MEAS);
585 }
586
scd4x_disable_regulator(void * data)587 static void scd4x_disable_regulator(void *data)
588 {
589 struct scd4x_state *state = data;
590
591 regulator_disable(state->vdd);
592 }
593
scd4x_trigger_handler(int irq,void * p)594 static irqreturn_t scd4x_trigger_handler(int irq, void *p)
595 {
596 struct iio_poll_func *pf = p;
597 struct iio_dev *indio_dev = pf->indio_dev;
598 struct scd4x_state *state = iio_priv(indio_dev);
599 struct {
600 uint16_t data[3];
601 int64_t ts __aligned(8);
602 } scan;
603 int ret;
604
605 memset(&scan, 0, sizeof(scan));
606 mutex_lock(&state->lock);
607 ret = scd4x_read_poll(state, scan.data);
608 mutex_unlock(&state->lock);
609 if (ret)
610 goto out;
611
612 iio_push_to_buffers_with_timestamp(indio_dev, &scan, iio_get_time_ns(indio_dev));
613 out:
614 iio_trigger_notify_done(indio_dev->trig);
615 return IRQ_HANDLED;
616 }
617
scd4x_probe(struct i2c_client * client,const struct i2c_device_id * id)618 static int scd4x_probe(struct i2c_client *client, const struct i2c_device_id *id)
619 {
620 static const unsigned long scd4x_scan_masks[] = { 0x07, 0x00 };
621 struct device *dev = &client->dev;
622 struct iio_dev *indio_dev;
623 struct scd4x_state *state;
624 int ret;
625
626 indio_dev = devm_iio_device_alloc(dev, sizeof(*state));
627 if (!indio_dev)
628 return -ENOMEM;
629
630 state = iio_priv(indio_dev);
631 mutex_init(&state->lock);
632 state->client = client;
633 crc8_populate_msb(scd4x_crc8_table, SCD4X_CRC8_POLYNOMIAL);
634
635 indio_dev->info = &scd4x_info;
636 indio_dev->name = client->name;
637 indio_dev->channels = scd4x_channels;
638 indio_dev->num_channels = ARRAY_SIZE(scd4x_channels);
639 indio_dev->modes = INDIO_DIRECT_MODE;
640 indio_dev->available_scan_masks = scd4x_scan_masks;
641
642 state->vdd = devm_regulator_get(dev, "vdd");
643 if (IS_ERR(state->vdd))
644 return dev_err_probe(dev, PTR_ERR(state->vdd), "failed to get regulator\n");
645
646 ret = regulator_enable(state->vdd);
647 if (ret)
648 return ret;
649
650 ret = devm_add_action_or_reset(dev, scd4x_disable_regulator, state);
651 if (ret)
652 return ret;
653
654 ret = scd4x_send_command(state, CMD_STOP_MEAS);
655 if (ret) {
656 dev_err(dev, "failed to stop measurement: %d\n", ret);
657 return ret;
658 }
659
660 /* execution time */
661 msleep_interruptible(500);
662
663 ret = devm_iio_triggered_buffer_setup(dev, indio_dev, NULL, scd4x_trigger_handler, NULL);
664 if (ret)
665 return ret;
666
667 ret = scd4x_send_command(state, CMD_START_MEAS);
668 if (ret) {
669 dev_err(dev, "failed to start measurement: %d\n", ret);
670 return ret;
671 }
672
673 ret = devm_add_action_or_reset(dev, scd4x_stop_meas, state);
674 if (ret)
675 return ret;
676
677 return devm_iio_device_register(dev, indio_dev);
678 }
679
680 static const struct of_device_id scd4x_dt_ids[] = {
681 { .compatible = "sensirion,scd40" },
682 { .compatible = "sensirion,scd41" },
683 { }
684 };
685 MODULE_DEVICE_TABLE(of, scd4x_dt_ids);
686
687 static struct i2c_driver scd4x_i2c_driver = {
688 .driver = {
689 .name = KBUILD_MODNAME,
690 .of_match_table = scd4x_dt_ids,
691 .pm = pm_sleep_ptr(&scd4x_pm_ops),
692 },
693 .probe = scd4x_probe,
694 };
695 module_i2c_driver(scd4x_i2c_driver);
696
697 MODULE_AUTHOR("Roan van Dijk <roan@protonic.nl>");
698 MODULE_DESCRIPTION("Sensirion SCD4X carbon dioxide sensor core driver");
699 MODULE_LICENSE("GPL v2");
700