ams-iaq-core.c 4.2 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * ams-iaq-core.c - Support for AMS iAQ-Core VOC sensors
  4. *
  5. * Copyright (C) 2015, 2018
  6. * Author: Matt Ranostay <matt.ranostay@konsulko.com>
  7. */
  8. #include <linux/module.h>
  9. #include <linux/mod_devicetable.h>
  10. #include <linux/mutex.h>
  11. #include <linux/init.h>
  12. #include <linux/i2c.h>
  13. #include <linux/iio/iio.h>
  14. #define AMS_IAQCORE_DATA_SIZE 9
  15. #define AMS_IAQCORE_VOC_CO2_IDX 0
  16. #define AMS_IAQCORE_VOC_RESISTANCE_IDX 1
  17. #define AMS_IAQCORE_VOC_TVOC_IDX 2
  18. struct ams_iaqcore_reading {
  19. __be16 co2_ppm;
  20. u8 status;
  21. __be32 resistance;
  22. __be16 voc_ppb;
  23. } __attribute__((__packed__));
  24. struct ams_iaqcore_data {
  25. struct i2c_client *client;
  26. struct mutex lock;
  27. unsigned long last_update;
  28. struct ams_iaqcore_reading buffer;
  29. };
  30. static const struct iio_chan_spec ams_iaqcore_channels[] = {
  31. {
  32. .type = IIO_CONCENTRATION,
  33. .channel2 = IIO_MOD_CO2,
  34. .modified = 1,
  35. .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED),
  36. .address = AMS_IAQCORE_VOC_CO2_IDX,
  37. },
  38. {
  39. .type = IIO_RESISTANCE,
  40. .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED),
  41. .address = AMS_IAQCORE_VOC_RESISTANCE_IDX,
  42. },
  43. {
  44. .type = IIO_CONCENTRATION,
  45. .channel2 = IIO_MOD_VOC,
  46. .modified = 1,
  47. .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED),
  48. .address = AMS_IAQCORE_VOC_TVOC_IDX,
  49. },
  50. };
  51. static int ams_iaqcore_read_measurement(struct ams_iaqcore_data *data)
  52. {
  53. struct i2c_client *client = data->client;
  54. int ret;
  55. struct i2c_msg msg = {
  56. .addr = client->addr,
  57. .flags = client->flags | I2C_M_RD,
  58. .len = AMS_IAQCORE_DATA_SIZE,
  59. .buf = (char *) &data->buffer,
  60. };
  61. ret = i2c_transfer(client->adapter, &msg, 1);
  62. return (ret == AMS_IAQCORE_DATA_SIZE) ? 0 : ret;
  63. }
  64. static int ams_iaqcore_get_measurement(struct ams_iaqcore_data *data)
  65. {
  66. int ret;
  67. /* sensor can only be polled once a second max per datasheet */
  68. if (!time_after(jiffies, data->last_update + HZ))
  69. return 0;
  70. ret = ams_iaqcore_read_measurement(data);
  71. if (ret < 0)
  72. return ret;
  73. data->last_update = jiffies;
  74. return 0;
  75. }
  76. static int ams_iaqcore_read_raw(struct iio_dev *indio_dev,
  77. struct iio_chan_spec const *chan, int *val,
  78. int *val2, long mask)
  79. {
  80. struct ams_iaqcore_data *data = iio_priv(indio_dev);
  81. int ret;
  82. if (mask != IIO_CHAN_INFO_PROCESSED)
  83. return -EINVAL;
  84. mutex_lock(&data->lock);
  85. ret = ams_iaqcore_get_measurement(data);
  86. if (ret)
  87. goto err_out;
  88. switch (chan->address) {
  89. case AMS_IAQCORE_VOC_CO2_IDX:
  90. *val = 0;
  91. *val2 = be16_to_cpu(data->buffer.co2_ppm);
  92. ret = IIO_VAL_INT_PLUS_MICRO;
  93. break;
  94. case AMS_IAQCORE_VOC_RESISTANCE_IDX:
  95. *val = be32_to_cpu(data->buffer.resistance);
  96. ret = IIO_VAL_INT;
  97. break;
  98. case AMS_IAQCORE_VOC_TVOC_IDX:
  99. *val = 0;
  100. *val2 = be16_to_cpu(data->buffer.voc_ppb);
  101. ret = IIO_VAL_INT_PLUS_NANO;
  102. break;
  103. default:
  104. ret = -EINVAL;
  105. }
  106. err_out:
  107. mutex_unlock(&data->lock);
  108. return ret;
  109. }
  110. static const struct iio_info ams_iaqcore_info = {
  111. .read_raw = ams_iaqcore_read_raw,
  112. };
  113. static int ams_iaqcore_probe(struct i2c_client *client,
  114. const struct i2c_device_id *id)
  115. {
  116. struct iio_dev *indio_dev;
  117. struct ams_iaqcore_data *data;
  118. indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
  119. if (!indio_dev)
  120. return -ENOMEM;
  121. data = iio_priv(indio_dev);
  122. i2c_set_clientdata(client, indio_dev);
  123. data->client = client;
  124. /* so initial reading will complete */
  125. data->last_update = jiffies - HZ;
  126. mutex_init(&data->lock);
  127. indio_dev->info = &ams_iaqcore_info;
  128. indio_dev->name = dev_name(&client->dev);
  129. indio_dev->modes = INDIO_DIRECT_MODE;
  130. indio_dev->channels = ams_iaqcore_channels;
  131. indio_dev->num_channels = ARRAY_SIZE(ams_iaqcore_channels);
  132. return devm_iio_device_register(&client->dev, indio_dev);
  133. }
  134. static const struct i2c_device_id ams_iaqcore_id[] = {
  135. { "ams-iaq-core", 0 },
  136. { }
  137. };
  138. MODULE_DEVICE_TABLE(i2c, ams_iaqcore_id);
  139. static const struct of_device_id ams_iaqcore_dt_ids[] = {
  140. { .compatible = "ams,iaq-core" },
  141. { }
  142. };
  143. MODULE_DEVICE_TABLE(of, ams_iaqcore_dt_ids);
  144. static struct i2c_driver ams_iaqcore_driver = {
  145. .driver = {
  146. .name = "ams-iaq-core",
  147. .of_match_table = ams_iaqcore_dt_ids,
  148. },
  149. .probe = ams_iaqcore_probe,
  150. .id_table = ams_iaqcore_id,
  151. };
  152. module_i2c_driver(ams_iaqcore_driver);
  153. MODULE_AUTHOR("Matt Ranostay <matt.ranostay@konsulko.com>");
  154. MODULE_DESCRIPTION("AMS iAQ-Core VOC sensors");
  155. MODULE_LICENSE("GPL v2");