ccs811.c 14 KB

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