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 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 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 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 */ 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 547 static void scd30_disable_regulator(void *data) 548 { 549 struct scd30_state *state = data; 550 551 regulator_disable(state->vdd); 552 } 553 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 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 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 memcpy(scan.data, state->meas, sizeof(state->meas)); 599 mutex_unlock(&state->lock); 600 if (ret) 601 goto out; 602 603 iio_push_to_buffers_with_ts(indio_dev, &scan, sizeof(scan), 604 iio_get_time_ns(indio_dev)); 605 out: 606 iio_trigger_notify_done(indio_dev->trig); 607 return IRQ_HANDLED; 608 } 609 610 static int scd30_set_trigger_state(struct iio_trigger *trig, bool state) 611 { 612 struct iio_dev *indio_dev = iio_trigger_get_drvdata(trig); 613 struct scd30_state *st = iio_priv(indio_dev); 614 615 if (state) 616 enable_irq(st->irq); 617 else 618 disable_irq(st->irq); 619 620 return 0; 621 } 622 623 static const struct iio_trigger_ops scd30_trigger_ops = { 624 .set_trigger_state = scd30_set_trigger_state, 625 .validate_device = iio_trigger_validate_own_device, 626 }; 627 628 static int scd30_setup_trigger(struct iio_dev *indio_dev) 629 { 630 struct scd30_state *state = iio_priv(indio_dev); 631 struct device *dev = indio_dev->dev.parent; 632 struct iio_trigger *trig; 633 int ret; 634 635 trig = devm_iio_trigger_alloc(dev, "%s-dev%d", indio_dev->name, 636 iio_device_id(indio_dev)); 637 if (!trig) 638 return dev_err_probe(dev, -ENOMEM, "failed to allocate trigger\n"); 639 640 trig->ops = &scd30_trigger_ops; 641 iio_trigger_set_drvdata(trig, indio_dev); 642 643 ret = devm_iio_trigger_register(dev, trig); 644 if (ret) 645 return ret; 646 647 indio_dev->trig = iio_trigger_get(trig); 648 649 /* 650 * Interrupt is enabled just before taking a fresh measurement 651 * and disabled afterwards. This means we need to ensure it is not 652 * enabled here to keep calls to enable/disable balanced. 653 */ 654 ret = devm_request_threaded_irq(dev, state->irq, scd30_irq_handler, 655 scd30_irq_thread_handler, 656 IRQF_TRIGGER_HIGH | IRQF_ONESHOT | 657 IRQF_NO_AUTOEN, 658 indio_dev->name, indio_dev); 659 if (ret) 660 return dev_err_probe(dev, ret, "failed to request irq\n"); 661 662 return 0; 663 } 664 665 int scd30_probe(struct device *dev, int irq, const char *name, void *priv, 666 scd30_command_t command) 667 { 668 static const unsigned long scd30_scan_masks[] = { 0x07, 0x00 }; 669 struct scd30_state *state; 670 struct iio_dev *indio_dev; 671 int ret; 672 u16 val; 673 674 indio_dev = devm_iio_device_alloc(dev, sizeof(*state)); 675 if (!indio_dev) 676 return -ENOMEM; 677 678 state = iio_priv(indio_dev); 679 state->dev = dev; 680 state->priv = priv; 681 state->irq = irq; 682 state->pressure_comp = SCD30_PRESSURE_COMP_DEFAULT; 683 state->meas_interval = SCD30_MEAS_INTERVAL_DEFAULT; 684 state->command = command; 685 mutex_init(&state->lock); 686 init_completion(&state->meas_ready); 687 688 dev_set_drvdata(dev, indio_dev); 689 690 indio_dev->info = &scd30_info; 691 indio_dev->name = name; 692 indio_dev->channels = scd30_channels; 693 indio_dev->num_channels = ARRAY_SIZE(scd30_channels); 694 indio_dev->modes = INDIO_DIRECT_MODE; 695 indio_dev->available_scan_masks = scd30_scan_masks; 696 697 state->vdd = devm_regulator_get(dev, "vdd"); 698 if (IS_ERR(state->vdd)) 699 return dev_err_probe(dev, PTR_ERR(state->vdd), "failed to get regulator\n"); 700 701 ret = regulator_enable(state->vdd); 702 if (ret) 703 return ret; 704 705 ret = devm_add_action_or_reset(dev, scd30_disable_regulator, state); 706 if (ret) 707 return ret; 708 709 ret = scd30_reset(state); 710 if (ret) 711 return dev_err_probe(dev, ret, "failed to reset device\n"); 712 713 if (state->irq > 0) { 714 ret = scd30_setup_trigger(indio_dev); 715 if (ret) 716 return dev_err_probe(dev, ret, "failed to setup trigger\n"); 717 } 718 719 ret = devm_iio_triggered_buffer_setup(dev, indio_dev, NULL, scd30_trigger_handler, NULL); 720 if (ret) 721 return ret; 722 723 ret = scd30_command_read(state, CMD_FW_VERSION, &val); 724 if (ret) 725 return dev_err_probe(dev, ret, "failed to read firmware version\n"); 726 dev_info(dev, "firmware version: %d.%d\n", val >> 8, (char)val); 727 728 ret = scd30_command_write(state, CMD_MEAS_INTERVAL, state->meas_interval); 729 if (ret) 730 return dev_err_probe(dev, ret, "failed to set measurement interval\n"); 731 732 ret = scd30_command_write(state, CMD_START_MEAS, state->pressure_comp); 733 if (ret) 734 return dev_err_probe(dev, ret, "failed to start measurement\n"); 735 736 ret = devm_add_action_or_reset(dev, scd30_stop_meas, state); 737 if (ret) 738 return ret; 739 740 return devm_iio_device_register(dev, indio_dev); 741 } 742 EXPORT_SYMBOL_NS(scd30_probe, "IIO_SCD30"); 743 744 MODULE_AUTHOR("Tomasz Duszynski <tomasz.duszynski@octakon.com>"); 745 MODULE_DESCRIPTION("Sensirion SCD30 carbon dioxide sensor core driver"); 746 MODULE_LICENSE("GPL v2"); 747