1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * Sensirion SCD30 carbon dioxide sensor core driver
4 *
5 * Copyright (c) 2020 Tomasz Duszynski <tomasz.duszynski@octakon.com>
6 */
7 #include <linux/bits.h>
8 #include <linux/cleanup.h>
9 #include <linux/completion.h>
10 #include <linux/delay.h>
11 #include <linux/device.h>
12 #include <linux/errno.h>
13 #include <linux/export.h>
14 #include <linux/iio/buffer.h>
15 #include <linux/iio/iio.h>
16 #include <linux/iio/sysfs.h>
17 #include <linux/iio/trigger.h>
18 #include <linux/iio/trigger_consumer.h>
19 #include <linux/iio/triggered_buffer.h>
20 #include <linux/iio/types.h>
21 #include <linux/interrupt.h>
22 #include <linux/irqreturn.h>
23 #include <linux/jiffies.h>
24 #include <linux/kernel.h>
25 #include <linux/module.h>
26 #include <linux/mutex.h>
27 #include <linux/regulator/consumer.h>
28 #include <linux/string.h>
29 #include <linux/sysfs.h>
30 #include <linux/types.h>
31 #include <asm/byteorder.h>
32
33 #include "scd30.h"
34
35 #define SCD30_PRESSURE_COMP_MIN_MBAR 700
36 #define SCD30_PRESSURE_COMP_MAX_MBAR 1400
37 #define SCD30_PRESSURE_COMP_DEFAULT 1013
38 #define SCD30_MEAS_INTERVAL_MIN_S 2
39 #define SCD30_MEAS_INTERVAL_MAX_S 1800
40 #define SCD30_MEAS_INTERVAL_DEFAULT SCD30_MEAS_INTERVAL_MIN_S
41 #define SCD30_FRC_MIN_PPM 400
42 #define SCD30_FRC_MAX_PPM 2000
43 #define SCD30_TEMP_OFFSET_MAX 655360
44 #define SCD30_EXTRA_TIMEOUT_PER_S 250
45
46 enum {
47 SCD30_CONC,
48 SCD30_TEMP,
49 SCD30_HR,
50 };
51
scd30_command_write(struct scd30_state * state,enum scd30_cmd cmd,u16 arg)52 static int scd30_command_write(struct scd30_state *state, enum scd30_cmd cmd, u16 arg)
53 {
54 return state->command(state, cmd, arg, NULL, 0);
55 }
56
scd30_command_read(struct scd30_state * state,enum scd30_cmd cmd,u16 * val)57 static int scd30_command_read(struct scd30_state *state, enum scd30_cmd cmd, u16 *val)
58 {
59 __be16 tmp;
60 int ret;
61
62 ret = state->command(state, cmd, 0, &tmp, sizeof(tmp));
63 *val = be16_to_cpup(&tmp);
64
65 return ret;
66 }
67
scd30_reset(struct scd30_state * state)68 static int scd30_reset(struct scd30_state *state)
69 {
70 int ret;
71 u16 val;
72
73 ret = scd30_command_write(state, CMD_RESET, 0);
74 if (ret)
75 return ret;
76
77 /* sensor boots up within 2 secs */
78 msleep(2000);
79 /*
80 * Power-on-reset causes sensor to produce some glitch on i2c bus and
81 * some controllers end up in error state. Try to recover by placing
82 * any data on the bus.
83 */
84 scd30_command_read(state, CMD_MEAS_READY, &val);
85
86 return 0;
87 }
88
89 /* simplified float to fixed point conversion with a scaling factor of 0.01 */
scd30_float_to_fp(int float32)90 static int scd30_float_to_fp(int float32)
91 {
92 int fraction, shift,
93 mantissa = float32 & GENMASK(22, 0),
94 sign = (float32 & BIT(31)) ? -1 : 1,
95 exp = (float32 & ~BIT(31)) >> 23;
96
97 /* special case 0 */
98 if (!exp && !mantissa)
99 return 0;
100
101 exp -= 127;
102 if (exp < 0) {
103 exp = -exp;
104 /* return values ranging from 1 to 99 */
105 return sign * ((((BIT(23) + mantissa) * 100) >> 23) >> exp);
106 }
107
108 /* return values starting at 100 */
109 shift = 23 - exp;
110 float32 = BIT(exp) + (mantissa >> shift);
111 fraction = mantissa & GENMASK(shift - 1, 0);
112
113 return sign * (float32 * 100 + ((fraction * 100) >> shift));
114 }
115
scd30_read_meas(struct scd30_state * state)116 static int scd30_read_meas(struct scd30_state *state)
117 {
118 int i, ret;
119
120 ret = state->command(state, CMD_READ_MEAS, 0, state->meas, sizeof(state->meas));
121 if (ret)
122 return ret;
123
124 be32_to_cpu_array(state->meas, (__be32 *)state->meas, ARRAY_SIZE(state->meas));
125
126 for (i = 0; i < ARRAY_SIZE(state->meas); i++)
127 state->meas[i] = scd30_float_to_fp(state->meas[i]);
128
129 /*
130 * co2 is left unprocessed while temperature and humidity are scaled
131 * to milli deg C and milli percent respectively.
132 */
133 state->meas[SCD30_TEMP] *= 10;
134 state->meas[SCD30_HR] *= 10;
135
136 return 0;
137 }
138
scd30_wait_meas_irq(struct scd30_state * state)139 static int scd30_wait_meas_irq(struct scd30_state *state)
140 {
141 int ret, timeout;
142
143 reinit_completion(&state->meas_ready);
144 enable_irq(state->irq);
145 timeout = msecs_to_jiffies(state->meas_interval * (1000 + SCD30_EXTRA_TIMEOUT_PER_S));
146 ret = wait_for_completion_interruptible_timeout(&state->meas_ready, timeout);
147 if (ret > 0)
148 ret = 0;
149 else if (!ret)
150 ret = -ETIMEDOUT;
151
152 disable_irq(state->irq);
153
154 return ret;
155 }
156
scd30_wait_meas_poll(struct scd30_state * state)157 static int scd30_wait_meas_poll(struct scd30_state *state)
158 {
159 int timeout = state->meas_interval * SCD30_EXTRA_TIMEOUT_PER_S, tries = 5;
160
161 do {
162 int ret;
163 u16 val;
164
165 ret = scd30_command_read(state, CMD_MEAS_READY, &val);
166 if (ret)
167 return -EIO;
168
169 /* new measurement available */
170 if (val)
171 break;
172
173 msleep_interruptible(timeout);
174 } while (--tries);
175
176 return tries ? 0 : -ETIMEDOUT;
177 }
178
scd30_read_poll(struct scd30_state * state)179 static int scd30_read_poll(struct scd30_state *state)
180 {
181 int ret;
182
183 ret = scd30_wait_meas_poll(state);
184 if (ret)
185 return ret;
186
187 return scd30_read_meas(state);
188 }
189
scd30_read(struct scd30_state * state)190 static int scd30_read(struct scd30_state *state)
191 {
192 if (state->irq > 0)
193 return scd30_wait_meas_irq(state);
194
195 return scd30_read_poll(state);
196 }
197
scd30_read_raw(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,int * val,int * val2,long mask)198 static int scd30_read_raw(struct iio_dev *indio_dev, struct iio_chan_spec const *chan,
199 int *val, int *val2, long mask)
200 {
201 struct scd30_state *state = iio_priv(indio_dev);
202 int ret;
203 u16 tmp;
204
205 guard(mutex)(&state->lock);
206 switch (mask) {
207 case IIO_CHAN_INFO_RAW:
208 case IIO_CHAN_INFO_PROCESSED:
209 if (chan->output) {
210 *val = state->pressure_comp;
211 return IIO_VAL_INT;
212 }
213
214 if (!iio_device_claim_direct(indio_dev))
215 return -EBUSY;
216
217 ret = scd30_read(state);
218 if (ret) {
219 iio_device_release_direct(indio_dev);
220 return ret;
221 }
222
223 *val = state->meas[chan->address];
224 iio_device_release_direct(indio_dev);
225 return IIO_VAL_INT;
226 case IIO_CHAN_INFO_SCALE:
227 *val = 0;
228 *val2 = 1;
229 return IIO_VAL_INT_PLUS_MICRO;
230 case IIO_CHAN_INFO_SAMP_FREQ:
231 ret = scd30_command_read(state, CMD_MEAS_INTERVAL, &tmp);
232 if (ret)
233 return ret;
234
235 *val = 0;
236 *val2 = 1000000000 / tmp;
237 return IIO_VAL_INT_PLUS_NANO;
238 case IIO_CHAN_INFO_CALIBBIAS:
239 ret = scd30_command_read(state, CMD_TEMP_OFFSET, &tmp);
240 if (ret)
241 return ret;
242
243 *val = tmp;
244 return IIO_VAL_INT;
245 default:
246 return -EINVAL;
247 }
248 }
249
scd30_write_raw(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,int val,int val2,long mask)250 static int scd30_write_raw(struct iio_dev *indio_dev, struct iio_chan_spec const *chan,
251 int val, int val2, long mask)
252 {
253 struct scd30_state *state = iio_priv(indio_dev);
254 int ret;
255
256 guard(mutex)(&state->lock);
257 switch (mask) {
258 case IIO_CHAN_INFO_SAMP_FREQ:
259 if (val)
260 return -EINVAL;
261
262 val = 1000000000 / val2;
263 if (val < SCD30_MEAS_INTERVAL_MIN_S || val > SCD30_MEAS_INTERVAL_MAX_S)
264 return -EINVAL;
265
266 ret = scd30_command_write(state, CMD_MEAS_INTERVAL, val);
267 if (ret)
268 return ret;
269
270 state->meas_interval = val;
271 return 0;
272 case IIO_CHAN_INFO_RAW:
273 switch (chan->type) {
274 case IIO_PRESSURE:
275 if (val < SCD30_PRESSURE_COMP_MIN_MBAR ||
276 val > SCD30_PRESSURE_COMP_MAX_MBAR)
277 return -EINVAL;
278
279 ret = scd30_command_write(state, CMD_START_MEAS, val);
280 if (ret)
281 return ret;
282
283 state->pressure_comp = val;
284 return 0;
285 default:
286 return -EINVAL;
287 }
288 case IIO_CHAN_INFO_CALIBBIAS:
289 if (val < 0 || val > SCD30_TEMP_OFFSET_MAX)
290 return -EINVAL;
291 /*
292 * Manufacturer does not explicitly specify min/max sensible
293 * values hence check is omitted for simplicity.
294 */
295 return scd30_command_write(state, CMD_TEMP_OFFSET / 10, val);
296 default:
297 return -EINVAL;
298 }
299 }
300
scd30_write_raw_get_fmt(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,long mask)301 static int scd30_write_raw_get_fmt(struct iio_dev *indio_dev, struct iio_chan_spec const *chan,
302 long mask)
303 {
304 switch (mask) {
305 case IIO_CHAN_INFO_SAMP_FREQ:
306 return IIO_VAL_INT_PLUS_NANO;
307 case IIO_CHAN_INFO_RAW:
308 case IIO_CHAN_INFO_CALIBBIAS:
309 return IIO_VAL_INT;
310 }
311
312 return -EINVAL;
313 }
314
315 static const int scd30_pressure_raw_available[] = {
316 SCD30_PRESSURE_COMP_MIN_MBAR, 1, SCD30_PRESSURE_COMP_MAX_MBAR,
317 };
318
319 static const int scd30_temp_calibbias_available[] = {
320 0, 10, SCD30_TEMP_OFFSET_MAX,
321 };
322
scd30_read_avail(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,const int ** vals,int * type,int * length,long mask)323 static int scd30_read_avail(struct iio_dev *indio_dev, struct iio_chan_spec const *chan,
324 const int **vals, int *type, int *length, long mask)
325 {
326 switch (mask) {
327 case IIO_CHAN_INFO_RAW:
328 *vals = scd30_pressure_raw_available;
329 *type = IIO_VAL_INT;
330
331 return IIO_AVAIL_RANGE;
332 case IIO_CHAN_INFO_CALIBBIAS:
333 *vals = scd30_temp_calibbias_available;
334 *type = IIO_VAL_INT;
335
336 return IIO_AVAIL_RANGE;
337 }
338
339 return -EINVAL;
340 }
341
sampling_frequency_available_show(struct device * dev,struct device_attribute * attr,char * buf)342 static ssize_t sampling_frequency_available_show(struct device *dev, struct device_attribute *attr,
343 char *buf)
344 {
345 int i = SCD30_MEAS_INTERVAL_MIN_S;
346 ssize_t len = 0;
347
348 do {
349 len += sysfs_emit_at(buf, len, "0.%09u ", 1000000000 / i);
350 /*
351 * Not all values fit PAGE_SIZE buffer hence print every 6th
352 * (each frequency differs by 6s in time domain from the
353 * adjacent). Unlisted but valid ones are still accepted.
354 */
355 i += 6;
356 } while (i <= SCD30_MEAS_INTERVAL_MAX_S);
357
358 buf[len - 1] = '\n';
359
360 return len;
361 }
362
calibration_auto_enable_show(struct device * dev,struct device_attribute * attr,char * buf)363 static ssize_t calibration_auto_enable_show(struct device *dev, struct device_attribute *attr,
364 char *buf)
365 {
366 struct iio_dev *indio_dev = dev_to_iio_dev(dev);
367 struct scd30_state *state = iio_priv(indio_dev);
368 int ret;
369 u16 val;
370
371 mutex_lock(&state->lock);
372 ret = scd30_command_read(state, CMD_ASC, &val);
373 mutex_unlock(&state->lock);
374
375 return ret ?: sysfs_emit(buf, "%d\n", val);
376 }
377
calibration_auto_enable_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t len)378 static ssize_t calibration_auto_enable_store(struct device *dev, struct device_attribute *attr,
379 const char *buf, size_t len)
380 {
381 struct iio_dev *indio_dev = dev_to_iio_dev(dev);
382 struct scd30_state *state = iio_priv(indio_dev);
383 bool val;
384 int ret;
385
386 ret = kstrtobool(buf, &val);
387 if (ret)
388 return ret;
389
390 mutex_lock(&state->lock);
391 ret = scd30_command_write(state, CMD_ASC, val);
392 mutex_unlock(&state->lock);
393
394 return ret ?: len;
395 }
396
calibration_forced_value_show(struct device * dev,struct device_attribute * attr,char * buf)397 static ssize_t calibration_forced_value_show(struct device *dev, struct device_attribute *attr,
398 char *buf)
399 {
400 struct iio_dev *indio_dev = dev_to_iio_dev(dev);
401 struct scd30_state *state = iio_priv(indio_dev);
402 int ret;
403 u16 val;
404
405 mutex_lock(&state->lock);
406 ret = scd30_command_read(state, CMD_FRC, &val);
407 mutex_unlock(&state->lock);
408
409 return ret ?: sysfs_emit(buf, "%d\n", val);
410 }
411
calibration_forced_value_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t len)412 static ssize_t calibration_forced_value_store(struct device *dev, struct device_attribute *attr,
413 const char *buf, size_t len)
414 {
415 struct iio_dev *indio_dev = dev_to_iio_dev(dev);
416 struct scd30_state *state = iio_priv(indio_dev);
417 int ret;
418 u16 val;
419
420 ret = kstrtou16(buf, 0, &val);
421 if (ret)
422 return ret;
423
424 if (val < SCD30_FRC_MIN_PPM || val > SCD30_FRC_MAX_PPM)
425 return -EINVAL;
426
427 mutex_lock(&state->lock);
428 ret = scd30_command_write(state, CMD_FRC, val);
429 mutex_unlock(&state->lock);
430
431 return ret ?: len;
432 }
433
434 static IIO_DEVICE_ATTR_RO(sampling_frequency_available, 0);
435 static IIO_DEVICE_ATTR_RW(calibration_auto_enable, 0);
436 static IIO_DEVICE_ATTR_RW(calibration_forced_value, 0);
437
438 static struct attribute *scd30_attrs[] = {
439 &iio_dev_attr_sampling_frequency_available.dev_attr.attr,
440 &iio_dev_attr_calibration_auto_enable.dev_attr.attr,
441 &iio_dev_attr_calibration_forced_value.dev_attr.attr,
442 NULL
443 };
444
445 static const struct attribute_group scd30_attr_group = {
446 .attrs = scd30_attrs,
447 };
448
449 static const struct iio_info scd30_info = {
450 .attrs = &scd30_attr_group,
451 .read_raw = scd30_read_raw,
452 .write_raw = scd30_write_raw,
453 .write_raw_get_fmt = scd30_write_raw_get_fmt,
454 .read_avail = scd30_read_avail,
455 };
456
457 #define SCD30_CHAN_SCAN_TYPE(_sign, _realbits) .scan_type = { \
458 .sign = _sign, \
459 .realbits = _realbits, \
460 .storagebits = 32, \
461 .endianness = IIO_CPU, \
462 }
463
464 static const struct iio_chan_spec scd30_channels[] = {
465 {
466 /*
467 * this channel is special in a sense we are pretending that
468 * sensor is able to change measurement chamber pressure but in
469 * fact we're just setting pressure compensation value
470 */
471 .type = IIO_PRESSURE,
472 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
473 .info_mask_separate_available = BIT(IIO_CHAN_INFO_RAW),
474 .output = 1,
475 .scan_index = -1,
476 },
477 {
478 .type = IIO_CONCENTRATION,
479 .channel2 = IIO_MOD_CO2,
480 .address = SCD30_CONC,
481 .scan_index = SCD30_CONC,
482 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
483 BIT(IIO_CHAN_INFO_SCALE),
484 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ),
485 .modified = 1,
486
487 SCD30_CHAN_SCAN_TYPE('u', 20),
488 },
489 {
490 .type = IIO_TEMP,
491 .address = SCD30_TEMP,
492 .scan_index = SCD30_TEMP,
493 .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED) |
494 BIT(IIO_CHAN_INFO_CALIBBIAS),
495 .info_mask_separate_available = BIT(IIO_CHAN_INFO_CALIBBIAS),
496 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ),
497
498 SCD30_CHAN_SCAN_TYPE('s', 18),
499 },
500 {
501 .type = IIO_HUMIDITYRELATIVE,
502 .address = SCD30_HR,
503 .scan_index = SCD30_HR,
504 .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED),
505 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ),
506
507 SCD30_CHAN_SCAN_TYPE('u', 17),
508 },
509 IIO_CHAN_SOFT_TIMESTAMP(3),
510 };
511
scd30_suspend(struct device * dev)512 static int scd30_suspend(struct device *dev)
513 {
514 struct iio_dev *indio_dev = dev_get_drvdata(dev);
515 struct scd30_state *state = iio_priv(indio_dev);
516 int ret;
517
518 ret = scd30_command_write(state, CMD_STOP_MEAS, 0);
519 if (ret)
520 return ret;
521
522 return regulator_disable(state->vdd);
523 }
524
scd30_resume(struct device * dev)525 static int scd30_resume(struct device *dev)
526 {
527 struct iio_dev *indio_dev = dev_get_drvdata(dev);
528 struct scd30_state *state = iio_priv(indio_dev);
529 int ret;
530
531 ret = regulator_enable(state->vdd);
532 if (ret)
533 return ret;
534
535 return scd30_command_write(state, CMD_START_MEAS, state->pressure_comp);
536 }
537
538 EXPORT_NS_SIMPLE_DEV_PM_OPS(scd30_pm_ops, scd30_suspend, scd30_resume, IIO_SCD30);
539
scd30_stop_meas(void * data)540 static void scd30_stop_meas(void *data)
541 {
542 struct scd30_state *state = data;
543
544 scd30_command_write(state, CMD_STOP_MEAS, 0);
545 }
546
scd30_disable_regulator(void * data)547 static void scd30_disable_regulator(void *data)
548 {
549 struct scd30_state *state = data;
550
551 regulator_disable(state->vdd);
552 }
553
scd30_irq_handler(int irq,void * priv)554 static irqreturn_t scd30_irq_handler(int irq, void *priv)
555 {
556 struct iio_dev *indio_dev = priv;
557
558 if (iio_buffer_enabled(indio_dev)) {
559 iio_trigger_poll(indio_dev->trig);
560
561 return IRQ_HANDLED;
562 }
563
564 return IRQ_WAKE_THREAD;
565 }
566
scd30_irq_thread_handler(int irq,void * priv)567 static irqreturn_t scd30_irq_thread_handler(int irq, void *priv)
568 {
569 struct iio_dev *indio_dev = priv;
570 struct scd30_state *state = iio_priv(indio_dev);
571 int ret;
572
573 ret = scd30_read_meas(state);
574 if (ret)
575 goto out;
576
577 complete_all(&state->meas_ready);
578 out:
579 return IRQ_HANDLED;
580 }
581
scd30_trigger_handler(int irq,void * p)582 static irqreturn_t scd30_trigger_handler(int irq, void *p)
583 {
584 struct iio_poll_func *pf = p;
585 struct iio_dev *indio_dev = pf->indio_dev;
586 struct scd30_state *state = iio_priv(indio_dev);
587 struct {
588 int data[SCD30_MEAS_COUNT];
589 aligned_s64 ts;
590 } scan;
591 int ret;
592
593 mutex_lock(&state->lock);
594 if (!iio_trigger_using_own(indio_dev))
595 ret = scd30_read_poll(state);
596 else
597 ret = scd30_read_meas(state);
598 memset(&scan, 0, sizeof(scan));
599 memcpy(scan.data, state->meas, sizeof(state->meas));
600 mutex_unlock(&state->lock);
601 if (ret)
602 goto out;
603
604 iio_push_to_buffers_with_ts(indio_dev, &scan, sizeof(scan),
605 iio_get_time_ns(indio_dev));
606 out:
607 iio_trigger_notify_done(indio_dev->trig);
608 return IRQ_HANDLED;
609 }
610
scd30_set_trigger_state(struct iio_trigger * trig,bool state)611 static int scd30_set_trigger_state(struct iio_trigger *trig, bool state)
612 {
613 struct iio_dev *indio_dev = iio_trigger_get_drvdata(trig);
614 struct scd30_state *st = iio_priv(indio_dev);
615
616 if (state)
617 enable_irq(st->irq);
618 else
619 disable_irq(st->irq);
620
621 return 0;
622 }
623
624 static const struct iio_trigger_ops scd30_trigger_ops = {
625 .set_trigger_state = scd30_set_trigger_state,
626 .validate_device = iio_trigger_validate_own_device,
627 };
628
scd30_setup_trigger(struct iio_dev * indio_dev)629 static int scd30_setup_trigger(struct iio_dev *indio_dev)
630 {
631 struct scd30_state *state = iio_priv(indio_dev);
632 struct device *dev = indio_dev->dev.parent;
633 struct iio_trigger *trig;
634 int ret;
635
636 trig = devm_iio_trigger_alloc(dev, "%s-dev%d", indio_dev->name,
637 iio_device_id(indio_dev));
638 if (!trig)
639 return dev_err_probe(dev, -ENOMEM, "failed to allocate trigger\n");
640
641 trig->ops = &scd30_trigger_ops;
642 iio_trigger_set_drvdata(trig, indio_dev);
643
644 ret = devm_iio_trigger_register(dev, trig);
645 if (ret)
646 return ret;
647
648 indio_dev->trig = iio_trigger_get(trig);
649
650 /*
651 * Interrupt is enabled just before taking a fresh measurement
652 * and disabled afterwards. This means we need to ensure it is not
653 * enabled here to keep calls to enable/disable balanced.
654 */
655 ret = devm_request_threaded_irq(dev, state->irq, scd30_irq_handler,
656 scd30_irq_thread_handler,
657 IRQF_TRIGGER_HIGH | IRQF_ONESHOT |
658 IRQF_NO_AUTOEN,
659 indio_dev->name, indio_dev);
660 if (ret)
661 return dev_err_probe(dev, ret, "failed to request irq\n");
662
663 return 0;
664 }
665
scd30_probe(struct device * dev,int irq,const char * name,void * priv,scd30_command_t command)666 int scd30_probe(struct device *dev, int irq, const char *name, void *priv,
667 scd30_command_t command)
668 {
669 static const unsigned long scd30_scan_masks[] = { 0x07, 0x00 };
670 struct scd30_state *state;
671 struct iio_dev *indio_dev;
672 int ret;
673 u16 val;
674
675 indio_dev = devm_iio_device_alloc(dev, sizeof(*state));
676 if (!indio_dev)
677 return -ENOMEM;
678
679 state = iio_priv(indio_dev);
680 state->dev = dev;
681 state->priv = priv;
682 state->irq = irq;
683 state->pressure_comp = SCD30_PRESSURE_COMP_DEFAULT;
684 state->meas_interval = SCD30_MEAS_INTERVAL_DEFAULT;
685 state->command = command;
686 mutex_init(&state->lock);
687 init_completion(&state->meas_ready);
688
689 dev_set_drvdata(dev, indio_dev);
690
691 indio_dev->info = &scd30_info;
692 indio_dev->name = name;
693 indio_dev->channels = scd30_channels;
694 indio_dev->num_channels = ARRAY_SIZE(scd30_channels);
695 indio_dev->modes = INDIO_DIRECT_MODE;
696 indio_dev->available_scan_masks = scd30_scan_masks;
697
698 state->vdd = devm_regulator_get(dev, "vdd");
699 if (IS_ERR(state->vdd))
700 return dev_err_probe(dev, PTR_ERR(state->vdd), "failed to get regulator\n");
701
702 ret = regulator_enable(state->vdd);
703 if (ret)
704 return ret;
705
706 ret = devm_add_action_or_reset(dev, scd30_disable_regulator, state);
707 if (ret)
708 return ret;
709
710 ret = scd30_reset(state);
711 if (ret)
712 return dev_err_probe(dev, ret, "failed to reset device\n");
713
714 if (state->irq > 0) {
715 ret = scd30_setup_trigger(indio_dev);
716 if (ret)
717 return dev_err_probe(dev, ret, "failed to setup trigger\n");
718 }
719
720 ret = devm_iio_triggered_buffer_setup(dev, indio_dev, NULL, scd30_trigger_handler, NULL);
721 if (ret)
722 return ret;
723
724 ret = scd30_command_read(state, CMD_FW_VERSION, &val);
725 if (ret)
726 return dev_err_probe(dev, ret, "failed to read firmware version\n");
727 dev_info(dev, "firmware version: %d.%d\n", val >> 8, (char)val);
728
729 ret = scd30_command_write(state, CMD_MEAS_INTERVAL, state->meas_interval);
730 if (ret)
731 return dev_err_probe(dev, ret, "failed to set measurement interval\n");
732
733 ret = scd30_command_write(state, CMD_START_MEAS, state->pressure_comp);
734 if (ret)
735 return dev_err_probe(dev, ret, "failed to start measurement\n");
736
737 ret = devm_add_action_or_reset(dev, scd30_stop_meas, state);
738 if (ret)
739 return ret;
740
741 return devm_iio_device_register(dev, indio_dev);
742 }
743 EXPORT_SYMBOL_NS(scd30_probe, "IIO_SCD30");
744
745 MODULE_AUTHOR("Tomasz Duszynski <tomasz.duszynski@octakon.com>");
746 MODULE_DESCRIPTION("Sensirion SCD30 carbon dioxide sensor core driver");
747 MODULE_LICENSE("GPL v2");
748