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