ti-adc161s626.c 5.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * ti-adc161s626.c - Texas Instruments ADC161S626 1-channel differential ADC
  4. *
  5. * ADC Devices Supported:
  6. * adc141s626 - 14-bit ADC
  7. * adc161s626 - 16-bit ADC
  8. *
  9. * Copyright (C) 2016-2018
  10. * Author: Matt Ranostay <matt.ranostay@konsulko.com>
  11. */
  12. #include <linux/module.h>
  13. #include <linux/mod_devicetable.h>
  14. #include <linux/init.h>
  15. #include <linux/err.h>
  16. #include <linux/spi/spi.h>
  17. #include <linux/iio/iio.h>
  18. #include <linux/iio/trigger.h>
  19. #include <linux/iio/buffer.h>
  20. #include <linux/iio/trigger_consumer.h>
  21. #include <linux/iio/triggered_buffer.h>
  22. #include <linux/regulator/consumer.h>
  23. #define TI_ADC_DRV_NAME "ti-adc161s626"
  24. enum {
  25. TI_ADC141S626,
  26. TI_ADC161S626,
  27. };
  28. static const struct iio_chan_spec ti_adc141s626_channels[] = {
  29. {
  30. .type = IIO_VOLTAGE,
  31. .channel = 0,
  32. .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
  33. BIT(IIO_CHAN_INFO_SCALE) |
  34. BIT(IIO_CHAN_INFO_OFFSET),
  35. .scan_index = 0,
  36. .scan_type = {
  37. .sign = 's',
  38. .realbits = 14,
  39. .storagebits = 16,
  40. },
  41. },
  42. IIO_CHAN_SOFT_TIMESTAMP(1),
  43. };
  44. static const struct iio_chan_spec ti_adc161s626_channels[] = {
  45. {
  46. .type = IIO_VOLTAGE,
  47. .channel = 0,
  48. .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
  49. BIT(IIO_CHAN_INFO_SCALE) |
  50. BIT(IIO_CHAN_INFO_OFFSET),
  51. .scan_index = 0,
  52. .scan_type = {
  53. .sign = 's',
  54. .realbits = 16,
  55. .storagebits = 16,
  56. },
  57. },
  58. IIO_CHAN_SOFT_TIMESTAMP(1),
  59. };
  60. struct ti_adc_data {
  61. struct iio_dev *indio_dev;
  62. struct spi_device *spi;
  63. struct regulator *ref;
  64. u8 read_size;
  65. u8 shift;
  66. u8 buffer[16] ____cacheline_aligned;
  67. };
  68. static int ti_adc_read_measurement(struct ti_adc_data *data,
  69. struct iio_chan_spec const *chan, int *val)
  70. {
  71. int ret;
  72. switch (data->read_size) {
  73. case 2: {
  74. __be16 buf;
  75. ret = spi_read(data->spi, (void *) &buf, 2);
  76. if (ret)
  77. return ret;
  78. *val = be16_to_cpu(buf);
  79. break;
  80. }
  81. case 3: {
  82. __be32 buf;
  83. ret = spi_read(data->spi, (void *) &buf, 3);
  84. if (ret)
  85. return ret;
  86. *val = be32_to_cpu(buf) >> 8;
  87. break;
  88. }
  89. default:
  90. return -EINVAL;
  91. }
  92. *val = sign_extend32(*val >> data->shift, chan->scan_type.realbits - 1);
  93. return 0;
  94. }
  95. static irqreturn_t ti_adc_trigger_handler(int irq, void *private)
  96. {
  97. struct iio_poll_func *pf = private;
  98. struct iio_dev *indio_dev = pf->indio_dev;
  99. struct ti_adc_data *data = iio_priv(indio_dev);
  100. int ret;
  101. ret = ti_adc_read_measurement(data, &indio_dev->channels[0],
  102. (int *) &data->buffer);
  103. if (!ret)
  104. iio_push_to_buffers_with_timestamp(indio_dev,
  105. data->buffer,
  106. iio_get_time_ns(indio_dev));
  107. iio_trigger_notify_done(indio_dev->trig);
  108. return IRQ_HANDLED;
  109. }
  110. static int ti_adc_read_raw(struct iio_dev *indio_dev,
  111. struct iio_chan_spec const *chan,
  112. int *val, int *val2, long mask)
  113. {
  114. struct ti_adc_data *data = iio_priv(indio_dev);
  115. int ret;
  116. switch (mask) {
  117. case IIO_CHAN_INFO_RAW:
  118. ret = iio_device_claim_direct_mode(indio_dev);
  119. if (ret)
  120. return ret;
  121. ret = ti_adc_read_measurement(data, chan, val);
  122. iio_device_release_direct_mode(indio_dev);
  123. if (ret)
  124. return ret;
  125. return IIO_VAL_INT;
  126. case IIO_CHAN_INFO_SCALE:
  127. ret = regulator_get_voltage(data->ref);
  128. if (ret < 0)
  129. return ret;
  130. *val = ret / 1000;
  131. *val2 = chan->scan_type.realbits;
  132. return IIO_VAL_FRACTIONAL_LOG2;
  133. case IIO_CHAN_INFO_OFFSET:
  134. *val = 1 << (chan->scan_type.realbits - 1);
  135. return IIO_VAL_INT;
  136. }
  137. return 0;
  138. }
  139. static const struct iio_info ti_adc_info = {
  140. .read_raw = ti_adc_read_raw,
  141. };
  142. static int ti_adc_probe(struct spi_device *spi)
  143. {
  144. struct iio_dev *indio_dev;
  145. struct ti_adc_data *data;
  146. int ret;
  147. indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*data));
  148. if (!indio_dev)
  149. return -ENOMEM;
  150. indio_dev->info = &ti_adc_info;
  151. indio_dev->name = TI_ADC_DRV_NAME;
  152. indio_dev->modes = INDIO_DIRECT_MODE;
  153. spi_set_drvdata(spi, indio_dev);
  154. data = iio_priv(indio_dev);
  155. data->spi = spi;
  156. switch (spi_get_device_id(spi)->driver_data) {
  157. case TI_ADC141S626:
  158. indio_dev->channels = ti_adc141s626_channels;
  159. indio_dev->num_channels = ARRAY_SIZE(ti_adc141s626_channels);
  160. data->shift = 0;
  161. data->read_size = 2;
  162. break;
  163. case TI_ADC161S626:
  164. indio_dev->channels = ti_adc161s626_channels;
  165. indio_dev->num_channels = ARRAY_SIZE(ti_adc161s626_channels);
  166. data->shift = 6;
  167. data->read_size = 3;
  168. break;
  169. }
  170. data->ref = devm_regulator_get(&spi->dev, "vdda");
  171. if (!IS_ERR(data->ref)) {
  172. ret = regulator_enable(data->ref);
  173. if (ret < 0)
  174. return ret;
  175. }
  176. ret = iio_triggered_buffer_setup(indio_dev, NULL,
  177. ti_adc_trigger_handler, NULL);
  178. if (ret)
  179. goto error_regulator_disable;
  180. ret = iio_device_register(indio_dev);
  181. if (ret)
  182. goto error_unreg_buffer;
  183. return 0;
  184. error_unreg_buffer:
  185. iio_triggered_buffer_cleanup(indio_dev);
  186. error_regulator_disable:
  187. regulator_disable(data->ref);
  188. return ret;
  189. }
  190. static int ti_adc_remove(struct spi_device *spi)
  191. {
  192. struct iio_dev *indio_dev = spi_get_drvdata(spi);
  193. struct ti_adc_data *data = iio_priv(indio_dev);
  194. iio_device_unregister(indio_dev);
  195. iio_triggered_buffer_cleanup(indio_dev);
  196. regulator_disable(data->ref);
  197. return 0;
  198. }
  199. static const struct of_device_id ti_adc_dt_ids[] = {
  200. { .compatible = "ti,adc141s626", },
  201. { .compatible = "ti,adc161s626", },
  202. {}
  203. };
  204. MODULE_DEVICE_TABLE(of, ti_adc_dt_ids);
  205. static const struct spi_device_id ti_adc_id[] = {
  206. {"adc141s626", TI_ADC141S626},
  207. {"adc161s626", TI_ADC161S626},
  208. {},
  209. };
  210. MODULE_DEVICE_TABLE(spi, ti_adc_id);
  211. static struct spi_driver ti_adc_driver = {
  212. .driver = {
  213. .name = TI_ADC_DRV_NAME,
  214. .of_match_table = ti_adc_dt_ids,
  215. },
  216. .probe = ti_adc_probe,
  217. .remove = ti_adc_remove,
  218. .id_table = ti_adc_id,
  219. };
  220. module_spi_driver(ti_adc_driver);
  221. MODULE_AUTHOR("Matt Ranostay <matt.ranostay@konsulko.com>");
  222. MODULE_DESCRIPTION("Texas Instruments ADC1x1S 1-channel differential ADC");
  223. MODULE_LICENSE("GPL");