drivers/iio/chemical/ccs811.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * ccs811.c - Support for AMS CCS811 VOC Sensor
   4  *
   5  * Copyright (C) 2017 Narcisa Vasile <[email protected]>
   6  *
   7  * Datasheet: ams.com/content/download/951091/2269479/CCS811_DS000459_3-00.pdf
   8  *
   9  * IIO driver for AMS CCS811 (I2C address 0x5A/0x5B set by ADDR Low/High)
  10  *
  11  * TODO:
  12  * 1. Make the drive mode selectable form userspace
  13  * 2. Add support for interrupts
  14  * 3. Adjust time to wait for data to be ready based on selected operation mode
  15  * 4. Read error register and put the information in logs
  16  */
  17
  18 #include <linux/delay.h>
  19 #include <linux/gpio/consumer.h>
  20 #include <linux/i2c.h>
  21 #include <linux/iio/iio.h>
  22 #include <linux/iio/buffer.h>
  23 #include <linux/iio/trigger.h>
  24 #include <linux/iio/triggered_buffer.h>
  25 #include <linux/iio/trigger_consumer.h>
  26 #include <linux/module.h>
  27
  28 #define CCS811_STATUS           0x00
  29 #define CCS811_MEAS_MODE        0x01
  30 #define CCS811_ALG_RESULT_DATA  0x02
  31 #define CCS811_RAW_DATA         0x03
  32 #define CCS811_HW_ID            0x20
  33 #define CCS811_HW_ID_VALUE      0x81
  34 #define CCS811_HW_VERSION       0x21
  35 #define CCS811_HW_VERSION_VALUE 0x10
  36 #define CCS811_HW_VERSION_MASK  0xF0
  37 #define CCS811_ERR              0xE0
  38 /* Used to transition from boot to application mode */
  39 #define CCS811_APP_START        0xF4
  40 #define CCS811_SW_RESET         0xFF
  41
  42 /* Status register flags */
  43 #define CCS811_STATUS_ERROR             BIT(0)
  44 #define CCS811_STATUS_DATA_READY        BIT(3)
  45 #define CCS811_STATUS_APP_VALID_MASK    BIT(4)
  46 #define CCS811_STATUS_APP_VALID_LOADED  BIT(4)
  47 /*
  48  * Value of FW_MODE bit of STATUS register describes the sensor's state:
  49  * 0: Firmware is in boot mode, this allows new firmware to be loaded
  50  * 1: Firmware is in application mode. CCS811 is ready to take ADC measurements
  51  */
  52 #define CCS811_STATUS_FW_MODE_MASK      BIT(7)
  53 #define CCS811_STATUS_FW_MODE_APPLICATION       BIT(7)
  54
  55 /* Measurement modes */
  56 #define CCS811_MODE_IDLE        0x00
  57 #define CCS811_MODE_IAQ_1SEC    0x10
  58 #define CCS811_MODE_IAQ_10SEC   0x20
  59 #define CCS811_MODE_IAQ_60SEC   0x30
  60 #define CCS811_MODE_RAW_DATA    0x40
  61
  62 #define CCS811_MEAS_MODE_INTERRUPT      BIT(3)
  63
  64 #define CCS811_VOLTAGE_MASK     0x3FF
  65
  66 struct ccs811_reading {
  67         __be16 co2;
  68         __be16 voc;
  69         u8 status;
  70         u8 error;
  71         __be16 raw_data;
  72 } __attribute__((__packed__));
  73
  74 struct ccs811_data {
  75         struct i2c_client *client;
  76         struct mutex lock; /* Protect readings */
  77         struct ccs811_reading buffer;
  78         struct iio_trigger *drdy_trig;
  79         struct gpio_desc *wakeup_gpio;
  80         bool drdy_trig_on;
  81         /* Ensures correct alignment of timestamp if present */
  82         struct {
  83                 s16 channels[2];
  84                 s64 ts __aligned(8);
  85         } scan;
  86 };
  87
  88 static const struct iio_chan_spec ccs811_channels[] = {
  89         {
  90                 .type = IIO_CURRENT,
  91                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
  92                                       BIT(IIO_CHAN_INFO_SCALE),
  93                 .scan_index = -1,
  94         }, {
  95                 .type = IIO_VOLTAGE,
  96                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
  97                                       BIT(IIO_CHAN_INFO_SCALE),
  98                 .scan_index = -1,
  99         }, {
 100                 .type = IIO_CONCENTRATION,
 101                 .channel2 = IIO_MOD_CO2,
 102                 .modified = 1,
 103                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
 104                                       BIT(IIO_CHAN_INFO_SCALE),
 105                 .scan_index = 0,
 106                 .scan_type = {
 107                         .sign = 'u',
 108                         .realbits = 16,
 109                         .storagebits = 16,
 110                         .endianness = IIO_BE,
 111                 },
 112         }, {
 113                 .type = IIO_CONCENTRATION,
 114                 .channel2 = IIO_MOD_VOC,
 115                 .modified = 1,
 116                 .info_mask_separate =  BIT(IIO_CHAN_INFO_RAW) |
 117                                        BIT(IIO_CHAN_INFO_SCALE),
 118                 .scan_index = 1,
 119                 .scan_type = {
 120                         .sign = 'u',
 121                         .realbits = 16,
 122                         .storagebits = 16,
 123                         .endianness = IIO_BE,
 124                 },
 125         },
 126         IIO_CHAN_SOFT_TIMESTAMP(2),
 127 };
 128
 129 /*
 130  * The CCS811 powers-up in boot mode. A setup write to CCS811_APP_START will
 131  * transition the sensor to application mode.
 132  */
 133 static int ccs811_start_sensor_application(struct i2c_client *client)
 134 {
 135         int ret;
 136
 137         ret = i2c_smbus_read_byte_data(client, CCS811_STATUS);
 138         if (ret < 0)
 139                 return ret;
 140
 141         if ((ret & CCS811_STATUS_FW_MODE_APPLICATION))
 142                 return 0;
 143
 144         if ((ret & CCS811_STATUS_APP_VALID_MASK) !=
 145             CCS811_STATUS_APP_VALID_LOADED)
 146                 return -EIO;
 147
 148         ret = i2c_smbus_write_byte(client, CCS811_APP_START);
 149         if (ret < 0)
 150                 return ret;
 151
 152         ret = i2c_smbus_read_byte_data(client, CCS811_STATUS);
 153         if (ret < 0)
 154                 return ret;
 155
 156         if ((ret & CCS811_STATUS_FW_MODE_MASK) !=
 157             CCS811_STATUS_FW_MODE_APPLICATION) {
 158                 dev_err(&client->dev, "Application failed to start. Sensor is still in boot mode.\n");
 159                 return -EIO;
 160         }
 161
 162         return 0;
 163 }
 164
 165 static int ccs811_setup(struct i2c_client *client)
 166 {
 167         int ret;
 168
 169         ret = ccs811_start_sensor_application(client);
 170         if (ret < 0)
 171                 return ret;
 172
 173         return i2c_smbus_write_byte_data(client, CCS811_MEAS_MODE,
 174                                          CCS811_MODE_IAQ_1SEC);
 175 }
 176
 177 static void ccs811_set_wakeup(struct ccs811_data *data, bool enable)
 178 {
 179         if (!data->wakeup_gpio)
 180                 return;
 181
 182         gpiod_set_value(data->wakeup_gpio, enable);
 183
 184         if (enable)
 185                 usleep_range(50, 60);
 186         else
 187                 usleep_range(20, 30);
 188 }
 189
 190 static int ccs811_get_measurement(struct ccs811_data *data)
 191 {
 192         int ret, tries = 11;
 193
 194         ccs811_set_wakeup(data, true);
 195
 196         /* Maximum waiting time: 1s, as measurements are made every second */
 197         while (tries-- > 0) {
 198                 ret = i2c_smbus_read_byte_data(data->client, CCS811_STATUS);
 199                 if (ret < 0)
 200                         return ret;
 201
 202                 if ((ret & CCS811_STATUS_DATA_READY) || tries == 0)
 203                         break;
 204                 msleep(100);
 205         }
 206         if (!(ret & CCS811_STATUS_DATA_READY))
 207                 return -EIO;
 208
 209         ret = i2c_smbus_read_i2c_block_data(data->client,
 210                                             CCS811_ALG_RESULT_DATA, 8,
 211                                             (char *)&data->buffer);
 212         ccs811_set_wakeup(data, false);
 213
 214         return ret;
 215 }
 216
 217 static int ccs811_read_raw(struct iio_dev *indio_dev,
 218                            struct iio_chan_spec const *chan,
 219                            int *val, int *val2, long mask)
 220 {
 221         struct ccs811_data *data = iio_priv(indio_dev);
 222         int ret;
 223
 224         switch (mask) {
 225         case IIO_CHAN_INFO_RAW:
 226                 ret = iio_device_claim_direct_mode(indio_dev);
 227                 if (ret)
 228                         return ret;
 229                 mutex_lock(&data->lock);
 230                 ret = ccs811_get_measurement(data);
 231                 if (ret < 0) {
 232                         mutex_unlock(&data->lock);
 233                         iio_device_release_direct_mode(indio_dev);
 234                         return ret;
 235                 }
 236
 237                 switch (chan->type) {
 238                 case IIO_VOLTAGE:
 239                         *val = be16_to_cpu(data->buffer.raw_data) &
 240                                            CCS811_VOLTAGE_MASK;
 241                         ret = IIO_VAL_INT;
 242                         break;
 243                 case IIO_CURRENT:
 244                         *val = be16_to_cpu(data->buffer.raw_data) >> 10;
 245                         ret = IIO_VAL_INT;
 246                         break;
 247                 case IIO_CONCENTRATION:
 248                         switch (chan->channel2) {
 249                         case IIO_MOD_CO2:
 250                                 *val = be16_to_cpu(data->buffer.co2);
 251                                 ret =  IIO_VAL_INT;
 252                                 break;
 253                         case IIO_MOD_VOC:
 254                                 *val = be16_to_cpu(data->buffer.voc);
 255                                 ret = IIO_VAL_INT;
 256                                 break;
 257                         default:
 258                                 ret = -EINVAL;
 259                         }
 260                         break;
 261                 default:
 262                         ret = -EINVAL;
 263                 }
 264                 mutex_unlock(&data->lock);
 265                 iio_device_release_direct_mode(indio_dev);
 266
 267                 return ret;
 268
 269         case IIO_CHAN_INFO_SCALE:
 270                 switch (chan->type) {
 271                 case IIO_VOLTAGE:
 272                         *val = 1;
 273                         *val2 = 612903;
 274                         return IIO_VAL_INT_PLUS_MICRO;
 275                 case IIO_CURRENT:
 276                         *val = 0;
 277                         *val2 = 1000;
 278                         return IIO_VAL_INT_PLUS_MICRO;
 279                 case IIO_CONCENTRATION:
 280                         switch (chan->channel2) {
 281                         case IIO_MOD_CO2:
 282                                 *val = 0;
 283                                 *val2 = 100;
 284                                 return IIO_VAL_INT_PLUS_MICRO;
 285                         case IIO_MOD_VOC:
 286                                 *val = 0;
 287                                 *val2 = 100;
 288                                 return IIO_VAL_INT_PLUS_NANO;
 289                         default:
 290                                 return -EINVAL;
 291                         }
 292                 default:
 293                         return -EINVAL;
 294                 }
 295         default:
 296                 return -EINVAL;
 297         }
 298 }
 299
 300 static const struct iio_info ccs811_info = {
 301         .read_raw = ccs811_read_raw,
 302 };
 303
 304 static int ccs811_set_trigger_state(struct iio_trigger *trig,
 305                                     bool state)
 306 {
 307         struct iio_dev *indio_dev = iio_trigger_get_drvdata(trig);
 308         struct ccs811_data *data = iio_priv(indio_dev);
 309         int ret;
 310
 311         ret = i2c_smbus_read_byte_data(data->client, CCS811_MEAS_MODE);
 312         if (ret < 0)
 313                 return ret;
 314
 315         if (state)
 316                 ret |= CCS811_MEAS_MODE_INTERRUPT;
 317         else
 318                 ret &= ~CCS811_MEAS_MODE_INTERRUPT;
 319
 320         data->drdy_trig_on = state;
 321
 322         return i2c_smbus_write_byte_data(data->client, CCS811_MEAS_MODE, ret);
 323 }
 324
 325 static const struct iio_trigger_ops ccs811_trigger_ops = {
 326         .set_trigger_state = ccs811_set_trigger_state,
 327 };
 328
 329 static irqreturn_t ccs811_trigger_handler(int irq, void *p)
 330 {
 331         struct iio_poll_func *pf = p;
 332         struct iio_dev *indio_dev = pf->indio_dev;
 333         struct ccs811_data *data = iio_priv(indio_dev);
 334         struct i2c_client *client = data->client;
 335         int ret;
 336
 337         ret = i2c_smbus_read_i2c_block_data(client, CCS811_ALG_RESULT_DATA,
 338                                             sizeof(data->scan.channels),
 339                                             (u8 *)data->scan.channels);
 340         if (ret != 4) {
 341                 dev_err(&client->dev, "cannot read sensor data\n");
 342                 goto err;
 343         }
 344
 345         iio_push_to_buffers_with_timestamp(indio_dev, &data->scan,
 346                                            iio_get_time_ns(indio_dev));
 347
 348 err:
 349         iio_trigger_notify_done(indio_dev->trig);
 350
 351         return IRQ_HANDLED;
 352 }
 353
 354 static irqreturn_t ccs811_data_rdy_trigger_poll(int irq, void *private)
 355 {
 356         struct iio_dev *indio_dev = private;
 357         struct ccs811_data *data = iio_priv(indio_dev);
 358
 359         if (data->drdy_trig_on)
 360                 iio_trigger_poll(data->drdy_trig);
 361
 362         return IRQ_HANDLED;
 363 }
 364
 365 static int ccs811_reset(struct i2c_client *client)
 366 {
 367         struct gpio_desc *reset_gpio;
 368         int ret;
 369
 370         reset_gpio = devm_gpiod_get_optional(&client->dev, "reset",
 371                                              GPIOD_OUT_LOW);
 372         if (IS_ERR(reset_gpio))
 373                 return PTR_ERR(reset_gpio);
 374
 375         /* Try to reset using nRESET pin if available else do SW reset */
 376         if (reset_gpio) {
 377                 gpiod_set_value(reset_gpio, 1);
 378                 usleep_range(20, 30);
 379                 gpiod_set_value(reset_gpio, 0);
 380         } else {
 381                 /*
 382                  * As per the datasheet, this sequence of values needs to be
 383                  * written to the SW_RESET register for triggering the soft
 384                  * reset in the device and placing it in boot mode.
 385                  */
 386                 static const u8 reset_seq[] = {
 387                         0x11, 0xE5, 0x72, 0x8A,
 388                 };
 389
 390                 ret = i2c_smbus_write_i2c_block_data(client, CCS811_SW_RESET,
 391                                              sizeof(reset_seq), reset_seq);
 392                 if (ret < 0) {
 393                         dev_err(&client->dev, "Failed to reset sensor\n");
 394                         return ret;
 395                 }
 396         }
 397
 398         /* tSTART delay required after reset */
 399         usleep_range(1000, 2000);
 400
 401         return 0;
 402 }
 403
 404 static int ccs811_probe(struct i2c_client *client)
 405 {
 406         const struct i2c_device_id *id = i2c_client_get_device_id(client);
 407         struct iio_dev *indio_dev;
 408         struct ccs811_data *data;
 409         int ret;
 410
 411         if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_WRITE_BYTE
 412                                      | I2C_FUNC_SMBUS_BYTE_DATA
 413                                      | I2C_FUNC_SMBUS_READ_I2C_BLOCK))
 414                 return -EOPNOTSUPP;
 415
 416         indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
 417         if (!indio_dev)
 418                 return -ENOMEM;
 419
 420         data = iio_priv(indio_dev);
 421         i2c_set_clientdata(client, indio_dev);
 422         data->client = client;
 423
 424         data->wakeup_gpio = devm_gpiod_get_optional(&client->dev, "wakeup",
 425                                                     GPIOD_OUT_HIGH);
 426         if (IS_ERR(data->wakeup_gpio))
 427                 return PTR_ERR(data->wakeup_gpio);
 428
 429         ccs811_set_wakeup(data, true);
 430
 431         ret = ccs811_reset(client);
 432         if (ret) {
 433                 ccs811_set_wakeup(data, false);
 434                 return ret;
 435         }
 436
 437         /* Check hardware id (should be 0x81 for this family of devices) */
 438         ret = i2c_smbus_read_byte_data(client, CCS811_HW_ID);
 439         if (ret < 0) {
 440                 ccs811_set_wakeup(data, false);
 441                 return ret;
 442         }
 443
 444         if (ret != CCS811_HW_ID_VALUE) {
 445                 dev_err(&client->dev, "hardware id doesn't match CCS81x\n");
 446                 ccs811_set_wakeup(data, false);
 447                 return -ENODEV;
 448         }
 449
 450         ret = i2c_smbus_read_byte_data(client, CCS811_HW_VERSION);
 451         if (ret < 0) {
 452                 ccs811_set_wakeup(data, false);
 453                 return ret;
 454         }
 455
 456         if ((ret & CCS811_HW_VERSION_MASK) != CCS811_HW_VERSION_VALUE) {
 457                 dev_err(&client->dev, "no CCS811 sensor\n");
 458                 ccs811_set_wakeup(data, false);
 459                 return -ENODEV;
 460         }
 461
 462         ret = ccs811_setup(client);
 463         if (ret < 0) {
 464                 ccs811_set_wakeup(data, false);
 465                 return ret;
 466         }
 467
 468         ccs811_set_wakeup(data, false);
 469
 470         mutex_init(&data->lock);
 471
 472         indio_dev->name = id->name;
 473         indio_dev->info = &ccs811_info;
 474         indio_dev->modes = INDIO_DIRECT_MODE;
 475
 476         indio_dev->channels = ccs811_channels;
 477         indio_dev->num_channels = ARRAY_SIZE(ccs811_channels);
 478
 479         if (client->irq > 0) {
 480                 ret = devm_request_threaded_irq(&client->dev, client->irq,
 481                                                 ccs811_data_rdy_trigger_poll,
 482                                                 NULL,
 483                                                 IRQF_TRIGGER_FALLING |
 484                                                 IRQF_ONESHOT,
 485                                                 "ccs811_irq", indio_dev);
 486                 if (ret) {
 487                         dev_err(&client->dev, "irq request error %d\n", -ret);
 488                         goto err_poweroff;
 489                 }
 490
 491                 data->drdy_trig = devm_iio_trigger_alloc(&client->dev,
 492                                                          "%s-dev%d",
 493                                                          indio_dev->name,
 494                                                          iio_device_id(indio_dev));
 495                 if (!data->drdy_trig) {
 496                         ret = -ENOMEM;
 497                         goto err_poweroff;
 498                 }
 499
 500                 data->drdy_trig->ops = &ccs811_trigger_ops;
 501                 iio_trigger_set_drvdata(data->drdy_trig, indio_dev);
 502                 ret = iio_trigger_register(data->drdy_trig);
 503                 if (ret)
 504                         goto err_poweroff;
 505
 506                 indio_dev->trig = iio_trigger_get(data->drdy_trig);
 507         }
 508
 509         ret = iio_triggered_buffer_setup(indio_dev, NULL,
 510                                          ccs811_trigger_handler, NULL);
 511
 512         if (ret < 0) {
 513                 dev_err(&client->dev, "triggered buffer setup failed\n");
 514                 goto err_trigger_unregister;
 515         }
 516
 517         ret = iio_device_register(indio_dev);
 518         if (ret < 0) {
 519                 dev_err(&client->dev, "unable to register iio device\n");
 520                 goto err_buffer_cleanup;
 521         }
 522         return 0;
 523
 524 err_buffer_cleanup:
 525         iio_triggered_buffer_cleanup(indio_dev);
 526 err_trigger_unregister:
 527         if (data->drdy_trig)
 528                 iio_trigger_unregister(data->drdy_trig);
 529 err_poweroff:
 530         i2c_smbus_write_byte_data(client, CCS811_MEAS_MODE, CCS811_MODE_IDLE);
 531
 532         return ret;
 533 }
 534
 535 static void ccs811_remove(struct i2c_client *client)
 536 {
 537         struct iio_dev *indio_dev = i2c_get_clientdata(client);
 538         struct ccs811_data *data = iio_priv(indio_dev);
 539         int ret;
 540
 541         iio_device_unregister(indio_dev);
 542         iio_triggered_buffer_cleanup(indio_dev);
 543         if (data->drdy_trig)
 544                 iio_trigger_unregister(data->drdy_trig);
 545
 546         ret = i2c_smbus_write_byte_data(client, CCS811_MEAS_MODE,
 547                                         CCS811_MODE_IDLE);
 548         if (ret)
 549                 dev_warn(&client->dev, "Failed to power down device (%pe)\n",
 550                          ERR_PTR(ret));
 551 }
 552
 553 static const struct i2c_device_id ccs811_id[] = {
 554         {"ccs811", 0},
 555         {       }
 556 };
 557 MODULE_DEVICE_TABLE(i2c, ccs811_id);
 558
 559 static const struct of_device_id ccs811_dt_ids[] = {
 560         { .compatible = "ams,ccs811" },
 561         { }
 562 };
 563 MODULE_DEVICE_TABLE(of, ccs811_dt_ids);
 564
 565 static struct i2c_driver ccs811_driver = {
 566         .driver = {
 567                 .name = "ccs811",
 568                 .of_match_table = ccs811_dt_ids,
 569         },
 570         .probe_new = ccs811_probe,
 571         .remove = ccs811_remove,
 572         .id_table = ccs811_id,
 573 };
 574 module_i2c_driver(ccs811_driver);
 575
 576 MODULE_AUTHOR("Narcisa Vasile <[email protected]>");
 577 MODULE_DESCRIPTION("CCS811 volatile organic compounds sensor");
 578 MODULE_LICENSE("GPL v2");