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