drivers/iio/chemical/scd4x.c

   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
  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
  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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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 (val == 0xff) {
 475                 dev_err(dev, "forced calibration has failed");
 476                 return -EINVAL;
 477         }
 478
 479         return ret ?: len;
 480 }
 481
 482 static IIO_DEVICE_ATTR_RW(calibration_auto_enable, 0);
 483 static IIO_DEVICE_ATTR_WO(calibration_forced_value, 0);
 484
 485 static IIO_CONST_ATTR(calibration_forced_value_available,
 486                __stringify([SCD4X_FRC_MIN_PPM 1 SCD4X_FRC_MAX_PPM]));
 487
 488 static struct attribute *scd4x_attrs[] = {
 489         &iio_dev_attr_calibration_auto_enable.dev_attr.attr,
 490         &iio_dev_attr_calibration_forced_value.dev_attr.attr,
 491         &iio_const_attr_calibration_forced_value_available.dev_attr.attr,
 492         NULL
 493 };
 494
 495 static const struct attribute_group scd4x_attr_group = {
 496         .attrs = scd4x_attrs,
 497 };
 498
 499 static const struct iio_info scd4x_info = {
 500         .attrs = &scd4x_attr_group,
 501         .read_raw = scd4x_read_raw,
 502         .write_raw = scd4x_write_raw,
 503 };
 504
 505 static const struct iio_chan_spec scd4x_channels[] = {
 506         {
 507                 .type = IIO_CONCENTRATION,
 508                 .channel2 = IIO_MOD_CO2,
 509                 .modified = 1,
 510                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
 511                                         BIT(IIO_CHAN_INFO_SCALE),
 512                 .address = SCD4X_CO2,
 513                 .scan_index = SCD4X_CO2,
 514                 .scan_type = {
 515                         .sign = 'u',
 516                         .realbits = 16,
 517                         .storagebits = 16,
 518                         .endianness = IIO_BE,
 519                 },
 520         },
 521         {
 522                 .type = IIO_TEMP,
 523                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
 524                                         BIT(IIO_CHAN_INFO_SCALE) |
 525                                         BIT(IIO_CHAN_INFO_OFFSET) |
 526                                         BIT(IIO_CHAN_INFO_CALIBBIAS),
 527                 .address = SCD4X_TEMP,
 528                 .scan_index = SCD4X_TEMP,
 529                 .scan_type = {
 530                         .sign = 'u',
 531                         .realbits = 16,
 532                         .storagebits = 16,
 533                         .endianness = IIO_BE,
 534                 },
 535         },
 536         {
 537                 .type = IIO_HUMIDITYRELATIVE,
 538                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
 539                                         BIT(IIO_CHAN_INFO_SCALE),
 540                 .address = SCD4X_HR,
 541                 .scan_index = SCD4X_HR,
 542                 .scan_type = {
 543                         .sign = 'u',
 544                         .realbits = 16,
 545                         .storagebits = 16,
 546                         .endianness = IIO_BE,
 547                 },
 548         },
 549 };
 550
 551 static int __maybe_unused scd4x_suspend(struct device *dev)
 552 {
 553         struct iio_dev *indio_dev = dev_get_drvdata(dev);
 554         struct scd4x_state *state  = iio_priv(indio_dev);
 555         int ret;
 556
 557         ret = scd4x_send_command(state, CMD_STOP_MEAS);
 558         if (ret)
 559                 return ret;
 560
 561         return regulator_disable(state->vdd);
 562 }
 563
 564 static int __maybe_unused scd4x_resume(struct device *dev)
 565 {
 566         struct iio_dev *indio_dev = dev_get_drvdata(dev);
 567         struct scd4x_state *state = iio_priv(indio_dev);
 568         int ret;
 569
 570         ret = regulator_enable(state->vdd);
 571         if (ret)
 572                 return ret;
 573
 574         return scd4x_send_command(state, CMD_START_MEAS);
 575 }
 576
 577 static __maybe_unused SIMPLE_DEV_PM_OPS(scd4x_pm_ops, scd4x_suspend, scd4x_resume);
 578
 579 static void scd4x_stop_meas(void *state)
 580 {
 581         scd4x_send_command(state, CMD_STOP_MEAS);
 582 }
 583
 584 static void scd4x_disable_regulator(void *data)
 585 {
 586         struct scd4x_state *state = data;
 587
 588         regulator_disable(state->vdd);
 589 }
 590
 591 static irqreturn_t scd4x_trigger_handler(int irq, void *p)
 592 {
 593         struct iio_poll_func *pf = p;
 594         struct iio_dev *indio_dev = pf->indio_dev;
 595         struct scd4x_state *state = iio_priv(indio_dev);
 596         struct {
 597                 uint16_t data[3];
 598                 int64_t ts __aligned(8);
 599         } scan;
 600         int ret;
 601
 602         memset(&scan, 0, sizeof(scan));
 603         mutex_lock(&state->lock);
 604         ret = scd4x_read_poll(state, scan.data);
 605         mutex_unlock(&state->lock);
 606         if (ret)
 607                 goto out;
 608
 609         iio_push_to_buffers_with_timestamp(indio_dev, &scan, iio_get_time_ns(indio_dev));
 610 out:
 611         iio_trigger_notify_done(indio_dev->trig);
 612         return IRQ_HANDLED;
 613 }
 614
 615 static int scd4x_probe(struct i2c_client *client, const struct i2c_device_id *id)
 616 {
 617         static const unsigned long scd4x_scan_masks[] = { 0x07, 0x00 };
 618         struct device *dev = &client->dev;
 619         struct iio_dev *indio_dev;
 620         struct scd4x_state *state;
 621         int ret;
 622
 623         indio_dev = devm_iio_device_alloc(dev, sizeof(*state));
 624         if (!indio_dev)
 625                 return -ENOMEM;
 626
 627         state = iio_priv(indio_dev);
 628         mutex_init(&state->lock);
 629         state->client = client;
 630         crc8_populate_msb(scd4x_crc8_table, SCD4X_CRC8_POLYNOMIAL);
 631
 632         indio_dev->info = &scd4x_info;
 633         indio_dev->name = client->name;
 634         indio_dev->channels = scd4x_channels;
 635         indio_dev->num_channels = ARRAY_SIZE(scd4x_channels);
 636         indio_dev->modes = INDIO_DIRECT_MODE;
 637         indio_dev->available_scan_masks = scd4x_scan_masks;
 638
 639         state->vdd = devm_regulator_get(dev, "vdd");
 640         if (IS_ERR(state->vdd))
 641                 return dev_err_probe(dev, PTR_ERR(state->vdd), "failed to get regulator\n");
 642
 643         ret = regulator_enable(state->vdd);
 644         if (ret)
 645                 return ret;
 646
 647         ret = devm_add_action_or_reset(dev, scd4x_disable_regulator, state);
 648         if (ret)
 649                 return ret;
 650
 651         ret = scd4x_send_command(state, CMD_STOP_MEAS);
 652         if (ret) {
 653                 dev_err(dev, "failed to stop measurement: %d\n", ret);
 654                 return ret;
 655         }
 656
 657         /* execution time */
 658         msleep_interruptible(500);
 659
 660         ret = devm_iio_triggered_buffer_setup(dev, indio_dev, NULL, scd4x_trigger_handler, NULL);
 661         if (ret)
 662                 return ret;
 663
 664         ret = scd4x_send_command(state, CMD_START_MEAS);
 665         if (ret) {
 666                 dev_err(dev, "failed to start measurement: %d\n", ret);
 667                 return ret;
 668         }
 669
 670         ret = devm_add_action_or_reset(dev, scd4x_stop_meas, state);
 671         if (ret)
 672                 return ret;
 673
 674         return devm_iio_device_register(dev, indio_dev);
 675 }
 676
 677 static const struct of_device_id scd4x_dt_ids[] = {
 678         { .compatible = "sensirion,scd40" },
 679         { .compatible = "sensirion,scd41" },
 680         { }
 681 };
 682 MODULE_DEVICE_TABLE(of, scd4x_dt_ids);
 683
 684 static struct i2c_driver scd4x_i2c_driver = {
 685         .driver = {
 686                 .name = KBUILD_MODNAME,
 687                 .of_match_table = scd4x_dt_ids,
 688                 .pm = &scd4x_pm_ops
 689         },
 690         .probe = scd4x_probe,
 691 };
 692 module_i2c_driver(scd4x_i2c_driver);
 693
 694 MODULE_AUTHOR("Roan van Dijk <roan@protonic.nl>");
 695 MODULE_DESCRIPTION("Sensirion SCD4X carbon dioxide sensor core driver");
 696 MODULE_LICENSE("GPL v2");