vz89x.c 9.2 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * vz89x.c - Support for SGX Sensortech MiCS VZ89X 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/mutex.h>
  10. #include <linux/init.h>
  11. #include <linux/i2c.h>
  12. #include <linux/mod_devicetable.h>
  13. #include <linux/iio/iio.h>
  14. #include <linux/iio/sysfs.h>
  15. #define VZ89X_REG_MEASUREMENT 0x09
  16. #define VZ89X_REG_MEASUREMENT_RD_SIZE 6
  17. #define VZ89X_REG_MEASUREMENT_WR_SIZE 3
  18. #define VZ89X_VOC_CO2_IDX 0
  19. #define VZ89X_VOC_SHORT_IDX 1
  20. #define VZ89X_VOC_TVOC_IDX 2
  21. #define VZ89X_VOC_RESISTANCE_IDX 3
  22. #define VZ89TE_REG_MEASUREMENT 0x0c
  23. #define VZ89TE_REG_MEASUREMENT_RD_SIZE 7
  24. #define VZ89TE_REG_MEASUREMENT_WR_SIZE 6
  25. #define VZ89TE_VOC_TVOC_IDX 0
  26. #define VZ89TE_VOC_CO2_IDX 1
  27. #define VZ89TE_VOC_RESISTANCE_IDX 2
  28. enum {
  29. VZ89X,
  30. VZ89TE,
  31. };
  32. struct vz89x_chip_data;
  33. struct vz89x_data {
  34. struct i2c_client *client;
  35. const struct vz89x_chip_data *chip;
  36. struct mutex lock;
  37. int (*xfer)(struct vz89x_data *data, u8 cmd);
  38. bool is_valid;
  39. unsigned long last_update;
  40. u8 buffer[VZ89TE_REG_MEASUREMENT_RD_SIZE];
  41. };
  42. struct vz89x_chip_data {
  43. bool (*valid)(struct vz89x_data *data);
  44. const struct iio_chan_spec *channels;
  45. u8 num_channels;
  46. u8 cmd;
  47. u8 read_size;
  48. u8 write_size;
  49. };
  50. static const struct iio_chan_spec vz89x_channels[] = {
  51. {
  52. .type = IIO_CONCENTRATION,
  53. .channel2 = IIO_MOD_CO2,
  54. .modified = 1,
  55. .info_mask_separate =
  56. BIT(IIO_CHAN_INFO_OFFSET) | BIT(IIO_CHAN_INFO_RAW),
  57. .address = VZ89X_VOC_CO2_IDX,
  58. },
  59. {
  60. .type = IIO_CONCENTRATION,
  61. .channel2 = IIO_MOD_VOC,
  62. .modified = 1,
  63. .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
  64. .address = VZ89X_VOC_SHORT_IDX,
  65. .extend_name = "short",
  66. },
  67. {
  68. .type = IIO_CONCENTRATION,
  69. .channel2 = IIO_MOD_VOC,
  70. .modified = 1,
  71. .info_mask_separate =
  72. BIT(IIO_CHAN_INFO_OFFSET) | BIT(IIO_CHAN_INFO_RAW),
  73. .address = VZ89X_VOC_TVOC_IDX,
  74. },
  75. {
  76. .type = IIO_RESISTANCE,
  77. .info_mask_separate =
  78. BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
  79. .address = VZ89X_VOC_RESISTANCE_IDX,
  80. .scan_index = -1,
  81. .scan_type = {
  82. .endianness = IIO_LE,
  83. },
  84. },
  85. };
  86. static const struct iio_chan_spec vz89te_channels[] = {
  87. {
  88. .type = IIO_CONCENTRATION,
  89. .channel2 = IIO_MOD_VOC,
  90. .modified = 1,
  91. .info_mask_separate =
  92. BIT(IIO_CHAN_INFO_OFFSET) | BIT(IIO_CHAN_INFO_RAW),
  93. .address = VZ89TE_VOC_TVOC_IDX,
  94. },
  95. {
  96. .type = IIO_CONCENTRATION,
  97. .channel2 = IIO_MOD_CO2,
  98. .modified = 1,
  99. .info_mask_separate =
  100. BIT(IIO_CHAN_INFO_OFFSET) | BIT(IIO_CHAN_INFO_RAW),
  101. .address = VZ89TE_VOC_CO2_IDX,
  102. },
  103. {
  104. .type = IIO_RESISTANCE,
  105. .info_mask_separate =
  106. BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
  107. .address = VZ89TE_VOC_RESISTANCE_IDX,
  108. .scan_index = -1,
  109. .scan_type = {
  110. .endianness = IIO_BE,
  111. },
  112. },
  113. };
  114. static IIO_CONST_ATTR(in_concentration_co2_scale, "0.00000698689");
  115. static IIO_CONST_ATTR(in_concentration_voc_scale, "0.00000000436681223");
  116. static struct attribute *vz89x_attributes[] = {
  117. &iio_const_attr_in_concentration_co2_scale.dev_attr.attr,
  118. &iio_const_attr_in_concentration_voc_scale.dev_attr.attr,
  119. NULL,
  120. };
  121. static const struct attribute_group vz89x_attrs_group = {
  122. .attrs = vz89x_attributes,
  123. };
  124. /*
  125. * Chipset sometime updates in the middle of a reading causing it to reset the
  126. * data pointer, and causing invalid reading of previous data.
  127. * We can check for this by reading MSB of the resistance reading that is
  128. * always zero, and by also confirming the VOC_short isn't zero.
  129. */
  130. static bool vz89x_measurement_is_valid(struct vz89x_data *data)
  131. {
  132. if (data->buffer[VZ89X_VOC_SHORT_IDX] == 0)
  133. return true;
  134. return !!(data->buffer[data->chip->read_size - 1] > 0);
  135. }
  136. /* VZ89TE device has a modified CRC-8 two complement check */
  137. static bool vz89te_measurement_is_valid(struct vz89x_data *data)
  138. {
  139. u8 crc = 0;
  140. int i, sum = 0;
  141. for (i = 0; i < (data->chip->read_size - 1); i++) {
  142. sum = crc + data->buffer[i];
  143. crc = sum;
  144. crc += sum / 256;
  145. }
  146. return !((0xff - crc) == data->buffer[data->chip->read_size - 1]);
  147. }
  148. static int vz89x_i2c_xfer(struct vz89x_data *data, u8 cmd)
  149. {
  150. const struct vz89x_chip_data *chip = data->chip;
  151. struct i2c_client *client = data->client;
  152. struct i2c_msg msg[2];
  153. int ret;
  154. u8 buf[6] = { cmd, 0, 0, 0, 0, 0xf3 };
  155. msg[0].addr = client->addr;
  156. msg[0].flags = client->flags;
  157. msg[0].len = chip->write_size;
  158. msg[0].buf = (char *) &buf;
  159. msg[1].addr = client->addr;
  160. msg[1].flags = client->flags | I2C_M_RD;
  161. msg[1].len = chip->read_size;
  162. msg[1].buf = (char *) &data->buffer;
  163. ret = i2c_transfer(client->adapter, msg, 2);
  164. return (ret == 2) ? 0 : ret;
  165. }
  166. static int vz89x_smbus_xfer(struct vz89x_data *data, u8 cmd)
  167. {
  168. struct i2c_client *client = data->client;
  169. int ret;
  170. int i;
  171. ret = i2c_smbus_write_word_data(client, cmd, 0);
  172. if (ret < 0)
  173. return ret;
  174. for (i = 0; i < data->chip->read_size; i++) {
  175. ret = i2c_smbus_read_byte(client);
  176. if (ret < 0)
  177. return ret;
  178. data->buffer[i] = ret;
  179. }
  180. return 0;
  181. }
  182. static int vz89x_get_measurement(struct vz89x_data *data)
  183. {
  184. const struct vz89x_chip_data *chip = data->chip;
  185. int ret;
  186. /* sensor can only be polled once a second max per datasheet */
  187. if (!time_after(jiffies, data->last_update + HZ))
  188. return data->is_valid ? 0 : -EAGAIN;
  189. data->is_valid = false;
  190. data->last_update = jiffies;
  191. ret = data->xfer(data, chip->cmd);
  192. if (ret < 0)
  193. return ret;
  194. ret = chip->valid(data);
  195. if (ret)
  196. return -EAGAIN;
  197. data->is_valid = true;
  198. return 0;
  199. }
  200. static int vz89x_get_resistance_reading(struct vz89x_data *data,
  201. struct iio_chan_spec const *chan,
  202. int *val)
  203. {
  204. u8 *tmp = (u8 *) &data->buffer[chan->address];
  205. switch (chan->scan_type.endianness) {
  206. case IIO_LE:
  207. *val = le32_to_cpup((__le32 *) tmp) & GENMASK(23, 0);
  208. break;
  209. case IIO_BE:
  210. *val = be32_to_cpup((__be32 *) tmp) >> 8;
  211. break;
  212. default:
  213. return -EINVAL;
  214. }
  215. return 0;
  216. }
  217. static int vz89x_read_raw(struct iio_dev *indio_dev,
  218. struct iio_chan_spec const *chan, int *val,
  219. int *val2, long mask)
  220. {
  221. struct vz89x_data *data = iio_priv(indio_dev);
  222. int ret = -EINVAL;
  223. switch (mask) {
  224. case IIO_CHAN_INFO_RAW:
  225. mutex_lock(&data->lock);
  226. ret = vz89x_get_measurement(data);
  227. mutex_unlock(&data->lock);
  228. if (ret)
  229. return ret;
  230. switch (chan->type) {
  231. case IIO_CONCENTRATION:
  232. *val = data->buffer[chan->address];
  233. return IIO_VAL_INT;
  234. case IIO_RESISTANCE:
  235. ret = vz89x_get_resistance_reading(data, chan, val);
  236. if (!ret)
  237. return IIO_VAL_INT;
  238. break;
  239. default:
  240. return -EINVAL;
  241. }
  242. break;
  243. case IIO_CHAN_INFO_SCALE:
  244. switch (chan->type) {
  245. case IIO_RESISTANCE:
  246. *val = 10;
  247. return IIO_VAL_INT;
  248. default:
  249. return -EINVAL;
  250. }
  251. break;
  252. case IIO_CHAN_INFO_OFFSET:
  253. switch (chan->channel2) {
  254. case IIO_MOD_CO2:
  255. *val = 44;
  256. *val2 = 250000;
  257. return IIO_VAL_INT_PLUS_MICRO;
  258. case IIO_MOD_VOC:
  259. *val = -13;
  260. return IIO_VAL_INT;
  261. default:
  262. return -EINVAL;
  263. }
  264. }
  265. return ret;
  266. }
  267. static const struct iio_info vz89x_info = {
  268. .attrs = &vz89x_attrs_group,
  269. .read_raw = vz89x_read_raw,
  270. };
  271. static const struct vz89x_chip_data vz89x_chips[] = {
  272. {
  273. .valid = vz89x_measurement_is_valid,
  274. .cmd = VZ89X_REG_MEASUREMENT,
  275. .read_size = VZ89X_REG_MEASUREMENT_RD_SIZE,
  276. .write_size = VZ89X_REG_MEASUREMENT_WR_SIZE,
  277. .channels = vz89x_channels,
  278. .num_channels = ARRAY_SIZE(vz89x_channels),
  279. },
  280. {
  281. .valid = vz89te_measurement_is_valid,
  282. .cmd = VZ89TE_REG_MEASUREMENT,
  283. .read_size = VZ89TE_REG_MEASUREMENT_RD_SIZE,
  284. .write_size = VZ89TE_REG_MEASUREMENT_WR_SIZE,
  285. .channels = vz89te_channels,
  286. .num_channels = ARRAY_SIZE(vz89te_channels),
  287. },
  288. };
  289. static const struct of_device_id vz89x_dt_ids[] = {
  290. { .compatible = "sgx,vz89x", .data = (void *) VZ89X },
  291. { .compatible = "sgx,vz89te", .data = (void *) VZ89TE },
  292. { }
  293. };
  294. MODULE_DEVICE_TABLE(of, vz89x_dt_ids);
  295. static int vz89x_probe(struct i2c_client *client,
  296. const struct i2c_device_id *id)
  297. {
  298. struct device *dev = &client->dev;
  299. struct iio_dev *indio_dev;
  300. struct vz89x_data *data;
  301. int chip_id;
  302. indio_dev = devm_iio_device_alloc(dev, sizeof(*data));
  303. if (!indio_dev)
  304. return -ENOMEM;
  305. data = iio_priv(indio_dev);
  306. if (i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
  307. data->xfer = vz89x_i2c_xfer;
  308. else if (i2c_check_functionality(client->adapter,
  309. I2C_FUNC_SMBUS_WORD_DATA | I2C_FUNC_SMBUS_BYTE))
  310. data->xfer = vz89x_smbus_xfer;
  311. else
  312. return -EOPNOTSUPP;
  313. if (!dev_fwnode(dev))
  314. chip_id = id->driver_data;
  315. else
  316. chip_id = (unsigned long)device_get_match_data(dev);
  317. i2c_set_clientdata(client, indio_dev);
  318. data->client = client;
  319. data->chip = &vz89x_chips[chip_id];
  320. data->last_update = jiffies - HZ;
  321. mutex_init(&data->lock);
  322. indio_dev->info = &vz89x_info;
  323. indio_dev->name = dev_name(dev);
  324. indio_dev->modes = INDIO_DIRECT_MODE;
  325. indio_dev->channels = data->chip->channels;
  326. indio_dev->num_channels = data->chip->num_channels;
  327. return devm_iio_device_register(dev, indio_dev);
  328. }
  329. static const struct i2c_device_id vz89x_id[] = {
  330. { "vz89x", VZ89X },
  331. { "vz89te", VZ89TE },
  332. { }
  333. };
  334. MODULE_DEVICE_TABLE(i2c, vz89x_id);
  335. static struct i2c_driver vz89x_driver = {
  336. .driver = {
  337. .name = "vz89x",
  338. .of_match_table = vz89x_dt_ids,
  339. },
  340. .probe = vz89x_probe,
  341. .id_table = vz89x_id,
  342. };
  343. module_i2c_driver(vz89x_driver);
  344. MODULE_AUTHOR("Matt Ranostay <matt.ranostay@konsulko.com>");
  345. MODULE_DESCRIPTION("SGX Sensortech MiCS VZ89X VOC sensors");
  346. MODULE_LICENSE("GPL v2");