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