ad7091r-base.c 6.4 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297
  1. // SPDX-License-Identifier: GPL-2.0
  2. /*
  3. * AD7091RX Analog to Digital converter driver
  4. *
  5. * Copyright 2014-2019 Analog Devices Inc.
  6. */
  7. #include <linux/bitops.h>
  8. #include <linux/iio/events.h>
  9. #include <linux/iio/iio.h>
  10. #include <linux/interrupt.h>
  11. #include <linux/module.h>
  12. #include <linux/regmap.h>
  13. #include <linux/regulator/consumer.h>
  14. #include "ad7091r-base.h"
  15. #define AD7091R_REG_RESULT 0
  16. #define AD7091R_REG_CHANNEL 1
  17. #define AD7091R_REG_CONF 2
  18. #define AD7091R_REG_ALERT 3
  19. #define AD7091R_REG_CH_LOW_LIMIT(ch) ((ch) * 3 + 4)
  20. #define AD7091R_REG_CH_HIGH_LIMIT(ch) ((ch) * 3 + 5)
  21. #define AD7091R_REG_CH_HYSTERESIS(ch) ((ch) * 3 + 6)
  22. /* AD7091R_REG_RESULT */
  23. #define AD7091R_REG_RESULT_CH_ID(x) (((x) >> 13) & 0x3)
  24. #define AD7091R_REG_RESULT_CONV_RESULT(x) ((x) & 0xfff)
  25. /* AD7091R_REG_CONF */
  26. #define AD7091R_REG_CONF_AUTO BIT(8)
  27. #define AD7091R_REG_CONF_CMD BIT(10)
  28. #define AD7091R_REG_CONF_MODE_MASK \
  29. (AD7091R_REG_CONF_AUTO | AD7091R_REG_CONF_CMD)
  30. enum ad7091r_mode {
  31. AD7091R_MODE_SAMPLE,
  32. AD7091R_MODE_COMMAND,
  33. AD7091R_MODE_AUTOCYCLE,
  34. };
  35. struct ad7091r_state {
  36. struct device *dev;
  37. struct regmap *map;
  38. struct regulator *vref;
  39. const struct ad7091r_chip_info *chip_info;
  40. enum ad7091r_mode mode;
  41. struct mutex lock; /*lock to prevent concurent reads */
  42. };
  43. static int ad7091r_set_mode(struct ad7091r_state *st, enum ad7091r_mode mode)
  44. {
  45. int ret, conf;
  46. switch (mode) {
  47. case AD7091R_MODE_SAMPLE:
  48. conf = 0;
  49. break;
  50. case AD7091R_MODE_COMMAND:
  51. conf = AD7091R_REG_CONF_CMD;
  52. break;
  53. case AD7091R_MODE_AUTOCYCLE:
  54. conf = AD7091R_REG_CONF_AUTO;
  55. break;
  56. default:
  57. return -EINVAL;
  58. }
  59. ret = regmap_update_bits(st->map, AD7091R_REG_CONF,
  60. AD7091R_REG_CONF_MODE_MASK, conf);
  61. if (ret)
  62. return ret;
  63. st->mode = mode;
  64. return 0;
  65. }
  66. static int ad7091r_set_channel(struct ad7091r_state *st, unsigned int channel)
  67. {
  68. unsigned int dummy;
  69. int ret;
  70. /* AD7091R_REG_CHANNEL specified which channels to be converted */
  71. ret = regmap_write(st->map, AD7091R_REG_CHANNEL,
  72. BIT(channel) | (BIT(channel) << 8));
  73. if (ret)
  74. return ret;
  75. /*
  76. * There is a latency of one conversion before the channel conversion
  77. * sequence is updated
  78. */
  79. return regmap_read(st->map, AD7091R_REG_RESULT, &dummy);
  80. }
  81. static int ad7091r_read_one(struct iio_dev *iio_dev,
  82. unsigned int channel, unsigned int *read_val)
  83. {
  84. struct ad7091r_state *st = iio_priv(iio_dev);
  85. unsigned int val;
  86. int ret;
  87. ret = ad7091r_set_channel(st, channel);
  88. if (ret)
  89. return ret;
  90. ret = regmap_read(st->map, AD7091R_REG_RESULT, &val);
  91. if (ret)
  92. return ret;
  93. if (AD7091R_REG_RESULT_CH_ID(val) != channel)
  94. return -EIO;
  95. *read_val = AD7091R_REG_RESULT_CONV_RESULT(val);
  96. return 0;
  97. }
  98. static int ad7091r_read_raw(struct iio_dev *iio_dev,
  99. struct iio_chan_spec const *chan,
  100. int *val, int *val2, long m)
  101. {
  102. struct ad7091r_state *st = iio_priv(iio_dev);
  103. unsigned int read_val;
  104. int ret;
  105. mutex_lock(&st->lock);
  106. switch (m) {
  107. case IIO_CHAN_INFO_RAW:
  108. if (st->mode != AD7091R_MODE_COMMAND) {
  109. ret = -EBUSY;
  110. goto unlock;
  111. }
  112. ret = ad7091r_read_one(iio_dev, chan->channel, &read_val);
  113. if (ret)
  114. goto unlock;
  115. *val = read_val;
  116. ret = IIO_VAL_INT;
  117. break;
  118. case IIO_CHAN_INFO_SCALE:
  119. if (st->vref) {
  120. ret = regulator_get_voltage(st->vref);
  121. if (ret < 0)
  122. goto unlock;
  123. *val = ret / 1000;
  124. } else {
  125. *val = st->chip_info->vref_mV;
  126. }
  127. *val2 = chan->scan_type.realbits;
  128. ret = IIO_VAL_FRACTIONAL_LOG2;
  129. break;
  130. default:
  131. ret = -EINVAL;
  132. break;
  133. }
  134. unlock:
  135. mutex_unlock(&st->lock);
  136. return ret;
  137. }
  138. static const struct iio_info ad7091r_info = {
  139. .read_raw = ad7091r_read_raw,
  140. };
  141. static irqreturn_t ad7091r_event_handler(int irq, void *private)
  142. {
  143. struct ad7091r_state *st = (struct ad7091r_state *) private;
  144. struct iio_dev *iio_dev = dev_get_drvdata(st->dev);
  145. unsigned int i, read_val;
  146. int ret;
  147. s64 timestamp = iio_get_time_ns(iio_dev);
  148. ret = regmap_read(st->map, AD7091R_REG_ALERT, &read_val);
  149. if (ret)
  150. return IRQ_HANDLED;
  151. for (i = 0; i < st->chip_info->num_channels; i++) {
  152. if (read_val & BIT(i * 2))
  153. iio_push_event(iio_dev,
  154. IIO_UNMOD_EVENT_CODE(IIO_VOLTAGE, i,
  155. IIO_EV_TYPE_THRESH,
  156. IIO_EV_DIR_RISING), timestamp);
  157. if (read_val & BIT(i * 2 + 1))
  158. iio_push_event(iio_dev,
  159. IIO_UNMOD_EVENT_CODE(IIO_VOLTAGE, i,
  160. IIO_EV_TYPE_THRESH,
  161. IIO_EV_DIR_FALLING), timestamp);
  162. }
  163. return IRQ_HANDLED;
  164. }
  165. static void ad7091r_remove(void *data)
  166. {
  167. struct ad7091r_state *st = data;
  168. regulator_disable(st->vref);
  169. }
  170. int ad7091r_probe(struct device *dev, const char *name,
  171. const struct ad7091r_chip_info *chip_info,
  172. struct regmap *map, int irq)
  173. {
  174. struct iio_dev *iio_dev;
  175. struct ad7091r_state *st;
  176. int ret;
  177. iio_dev = devm_iio_device_alloc(dev, sizeof(*st));
  178. if (!iio_dev)
  179. return -ENOMEM;
  180. st = iio_priv(iio_dev);
  181. st->dev = dev;
  182. st->chip_info = chip_info;
  183. st->map = map;
  184. iio_dev->name = name;
  185. iio_dev->info = &ad7091r_info;
  186. iio_dev->modes = INDIO_DIRECT_MODE;
  187. iio_dev->num_channels = chip_info->num_channels;
  188. iio_dev->channels = chip_info->channels;
  189. if (irq) {
  190. ret = devm_request_threaded_irq(dev, irq, NULL,
  191. ad7091r_event_handler,
  192. IRQF_TRIGGER_FALLING | IRQF_ONESHOT, name, st);
  193. if (ret)
  194. return ret;
  195. }
  196. st->vref = devm_regulator_get_optional(dev, "vref");
  197. if (IS_ERR(st->vref)) {
  198. if (PTR_ERR(st->vref) == -EPROBE_DEFER)
  199. return -EPROBE_DEFER;
  200. st->vref = NULL;
  201. } else {
  202. ret = regulator_enable(st->vref);
  203. if (ret)
  204. return ret;
  205. ret = devm_add_action_or_reset(dev, ad7091r_remove, st);
  206. if (ret)
  207. return ret;
  208. }
  209. /* Use command mode by default to convert only desired channels*/
  210. ret = ad7091r_set_mode(st, AD7091R_MODE_COMMAND);
  211. if (ret)
  212. return ret;
  213. return devm_iio_device_register(dev, iio_dev);
  214. }
  215. EXPORT_SYMBOL_GPL(ad7091r_probe);
  216. static bool ad7091r_writeable_reg(struct device *dev, unsigned int reg)
  217. {
  218. switch (reg) {
  219. case AD7091R_REG_RESULT:
  220. case AD7091R_REG_ALERT:
  221. return false;
  222. default:
  223. return true;
  224. }
  225. }
  226. static bool ad7091r_volatile_reg(struct device *dev, unsigned int reg)
  227. {
  228. switch (reg) {
  229. case AD7091R_REG_RESULT:
  230. case AD7091R_REG_ALERT:
  231. return true;
  232. default:
  233. return false;
  234. }
  235. }
  236. const struct regmap_config ad7091r_regmap_config = {
  237. .reg_bits = 8,
  238. .val_bits = 16,
  239. .writeable_reg = ad7091r_writeable_reg,
  240. .volatile_reg = ad7091r_volatile_reg,
  241. };
  242. EXPORT_SYMBOL_GPL(ad7091r_regmap_config);
  243. MODULE_AUTHOR("Beniamin Bia <beniamin.bia@analog.com>");
  244. MODULE_DESCRIPTION("Analog Devices AD7091Rx multi-channel converters");
  245. MODULE_LICENSE("GPL v2");