ad7791.c 13 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * AD7787/AD7788/AD7789/AD7790/AD7791 SPI ADC driver
  4. *
  5. * Copyright 2012 Analog Devices Inc.
  6. * Author: Lars-Peter Clausen <lars@metafoo.de>
  7. */
  8. #include <linux/interrupt.h>
  9. #include <linux/device.h>
  10. #include <linux/kernel.h>
  11. #include <linux/slab.h>
  12. #include <linux/sysfs.h>
  13. #include <linux/spi/spi.h>
  14. #include <linux/regulator/consumer.h>
  15. #include <linux/err.h>
  16. #include <linux/sched.h>
  17. #include <linux/delay.h>
  18. #include <linux/module.h>
  19. #include <linux/iio/iio.h>
  20. #include <linux/iio/sysfs.h>
  21. #include <linux/iio/buffer.h>
  22. #include <linux/iio/trigger.h>
  23. #include <linux/iio/trigger_consumer.h>
  24. #include <linux/iio/triggered_buffer.h>
  25. #include <linux/iio/adc/ad_sigma_delta.h>
  26. #include <linux/platform_data/ad7791.h>
  27. #define AD7791_REG_COMM 0x0 /* For writes */
  28. #define AD7791_REG_STATUS 0x0 /* For reads */
  29. #define AD7791_REG_MODE 0x1
  30. #define AD7791_REG_FILTER 0x2
  31. #define AD7791_REG_DATA 0x3
  32. #define AD7791_MODE_CONTINUOUS 0x00
  33. #define AD7791_MODE_SINGLE 0x02
  34. #define AD7791_MODE_POWERDOWN 0x03
  35. #define AD7791_CH_AIN1P_AIN1N 0x00
  36. #define AD7791_CH_AIN2 0x01
  37. #define AD7791_CH_AIN1N_AIN1N 0x02
  38. #define AD7791_CH_AVDD_MONITOR 0x03
  39. #define AD7791_FILTER_CLK_DIV_1 (0x0 << 4)
  40. #define AD7791_FILTER_CLK_DIV_2 (0x1 << 4)
  41. #define AD7791_FILTER_CLK_DIV_4 (0x2 << 4)
  42. #define AD7791_FILTER_CLK_DIV_8 (0x3 << 4)
  43. #define AD7791_FILTER_CLK_MASK (0x3 << 4)
  44. #define AD7791_FILTER_RATE_120 0x0
  45. #define AD7791_FILTER_RATE_100 0x1
  46. #define AD7791_FILTER_RATE_33_3 0x2
  47. #define AD7791_FILTER_RATE_20 0x3
  48. #define AD7791_FILTER_RATE_16_6 0x4
  49. #define AD7791_FILTER_RATE_16_7 0x5
  50. #define AD7791_FILTER_RATE_13_3 0x6
  51. #define AD7791_FILTER_RATE_9_5 0x7
  52. #define AD7791_FILTER_RATE_MASK 0x7
  53. #define AD7791_MODE_BUFFER BIT(1)
  54. #define AD7791_MODE_UNIPOLAR BIT(2)
  55. #define AD7791_MODE_BURNOUT BIT(3)
  56. #define AD7791_MODE_SEL_MASK (0x3 << 6)
  57. #define AD7791_MODE_SEL(x) ((x) << 6)
  58. #define __AD7991_CHANNEL(_si, _channel1, _channel2, _address, _bits, \
  59. _storagebits, _shift, _extend_name, _type, _mask_all) \
  60. { \
  61. .type = (_type), \
  62. .differential = (_channel2 == -1 ? 0 : 1), \
  63. .indexed = 1, \
  64. .channel = (_channel1), \
  65. .channel2 = (_channel2), \
  66. .address = (_address), \
  67. .extend_name = (_extend_name), \
  68. .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | \
  69. BIT(IIO_CHAN_INFO_OFFSET), \
  70. .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE), \
  71. .info_mask_shared_by_all = _mask_all, \
  72. .scan_index = (_si), \
  73. .scan_type = { \
  74. .sign = 'u', \
  75. .realbits = (_bits), \
  76. .storagebits = (_storagebits), \
  77. .shift = (_shift), \
  78. .endianness = IIO_BE, \
  79. }, \
  80. }
  81. #define AD7991_SHORTED_CHANNEL(_si, _channel, _address, _bits, \
  82. _storagebits, _shift) \
  83. __AD7991_CHANNEL(_si, _channel, _channel, _address, _bits, \
  84. _storagebits, _shift, "shorted", IIO_VOLTAGE, \
  85. BIT(IIO_CHAN_INFO_SAMP_FREQ))
  86. #define AD7991_CHANNEL(_si, _channel, _address, _bits, \
  87. _storagebits, _shift) \
  88. __AD7991_CHANNEL(_si, _channel, -1, _address, _bits, \
  89. _storagebits, _shift, NULL, IIO_VOLTAGE, \
  90. BIT(IIO_CHAN_INFO_SAMP_FREQ))
  91. #define AD7991_DIFF_CHANNEL(_si, _channel1, _channel2, _address, _bits, \
  92. _storagebits, _shift) \
  93. __AD7991_CHANNEL(_si, _channel1, _channel2, _address, _bits, \
  94. _storagebits, _shift, NULL, IIO_VOLTAGE, \
  95. BIT(IIO_CHAN_INFO_SAMP_FREQ))
  96. #define AD7991_SUPPLY_CHANNEL(_si, _channel, _address, _bits, _storagebits, \
  97. _shift) \
  98. __AD7991_CHANNEL(_si, _channel, -1, _address, _bits, \
  99. _storagebits, _shift, "supply", IIO_VOLTAGE, \
  100. BIT(IIO_CHAN_INFO_SAMP_FREQ))
  101. #define DECLARE_AD7787_CHANNELS(name, bits, storagebits) \
  102. const struct iio_chan_spec name[] = { \
  103. AD7991_DIFF_CHANNEL(0, 0, 0, AD7791_CH_AIN1P_AIN1N, \
  104. (bits), (storagebits), 0), \
  105. AD7991_CHANNEL(1, 1, AD7791_CH_AIN2, (bits), (storagebits), 0), \
  106. AD7991_SHORTED_CHANNEL(2, 0, AD7791_CH_AIN1N_AIN1N, \
  107. (bits), (storagebits), 0), \
  108. AD7991_SUPPLY_CHANNEL(3, 2, AD7791_CH_AVDD_MONITOR, \
  109. (bits), (storagebits), 0), \
  110. IIO_CHAN_SOFT_TIMESTAMP(4), \
  111. }
  112. #define DECLARE_AD7791_CHANNELS(name, bits, storagebits) \
  113. const struct iio_chan_spec name[] = { \
  114. AD7991_DIFF_CHANNEL(0, 0, 0, AD7791_CH_AIN1P_AIN1N, \
  115. (bits), (storagebits), 0), \
  116. AD7991_SHORTED_CHANNEL(1, 0, AD7791_CH_AIN1N_AIN1N, \
  117. (bits), (storagebits), 0), \
  118. AD7991_SUPPLY_CHANNEL(2, 1, AD7791_CH_AVDD_MONITOR, \
  119. (bits), (storagebits), 0), \
  120. IIO_CHAN_SOFT_TIMESTAMP(3), \
  121. }
  122. static DECLARE_AD7787_CHANNELS(ad7787_channels, 24, 32);
  123. static DECLARE_AD7791_CHANNELS(ad7790_channels, 16, 16);
  124. static DECLARE_AD7791_CHANNELS(ad7791_channels, 24, 32);
  125. enum {
  126. AD7787,
  127. AD7788,
  128. AD7789,
  129. AD7790,
  130. AD7791,
  131. };
  132. enum ad7791_chip_info_flags {
  133. AD7791_FLAG_HAS_FILTER = (1 << 0),
  134. AD7791_FLAG_HAS_BUFFER = (1 << 1),
  135. AD7791_FLAG_HAS_UNIPOLAR = (1 << 2),
  136. AD7791_FLAG_HAS_BURNOUT = (1 << 3),
  137. };
  138. struct ad7791_chip_info {
  139. const struct iio_chan_spec *channels;
  140. unsigned int num_channels;
  141. enum ad7791_chip_info_flags flags;
  142. };
  143. static const struct ad7791_chip_info ad7791_chip_infos[] = {
  144. [AD7787] = {
  145. .channels = ad7787_channels,
  146. .num_channels = ARRAY_SIZE(ad7787_channels),
  147. .flags = AD7791_FLAG_HAS_FILTER | AD7791_FLAG_HAS_BUFFER |
  148. AD7791_FLAG_HAS_UNIPOLAR | AD7791_FLAG_HAS_BURNOUT,
  149. },
  150. [AD7788] = {
  151. .channels = ad7790_channels,
  152. .num_channels = ARRAY_SIZE(ad7790_channels),
  153. .flags = AD7791_FLAG_HAS_UNIPOLAR,
  154. },
  155. [AD7789] = {
  156. .channels = ad7791_channels,
  157. .num_channels = ARRAY_SIZE(ad7791_channels),
  158. .flags = AD7791_FLAG_HAS_UNIPOLAR,
  159. },
  160. [AD7790] = {
  161. .channels = ad7790_channels,
  162. .num_channels = ARRAY_SIZE(ad7790_channels),
  163. .flags = AD7791_FLAG_HAS_FILTER | AD7791_FLAG_HAS_BUFFER |
  164. AD7791_FLAG_HAS_BURNOUT,
  165. },
  166. [AD7791] = {
  167. .channels = ad7791_channels,
  168. .num_channels = ARRAY_SIZE(ad7791_channels),
  169. .flags = AD7791_FLAG_HAS_FILTER | AD7791_FLAG_HAS_BUFFER |
  170. AD7791_FLAG_HAS_UNIPOLAR | AD7791_FLAG_HAS_BURNOUT,
  171. },
  172. };
  173. struct ad7791_state {
  174. struct ad_sigma_delta sd;
  175. uint8_t mode;
  176. uint8_t filter;
  177. struct regulator *reg;
  178. const struct ad7791_chip_info *info;
  179. };
  180. static const int ad7791_sample_freq_avail[8][2] = {
  181. [AD7791_FILTER_RATE_120] = { 120, 0 },
  182. [AD7791_FILTER_RATE_100] = { 100, 0 },
  183. [AD7791_FILTER_RATE_33_3] = { 33, 300000 },
  184. [AD7791_FILTER_RATE_20] = { 20, 0 },
  185. [AD7791_FILTER_RATE_16_6] = { 16, 600000 },
  186. [AD7791_FILTER_RATE_16_7] = { 16, 700000 },
  187. [AD7791_FILTER_RATE_13_3] = { 13, 300000 },
  188. [AD7791_FILTER_RATE_9_5] = { 9, 500000 },
  189. };
  190. static struct ad7791_state *ad_sigma_delta_to_ad7791(struct ad_sigma_delta *sd)
  191. {
  192. return container_of(sd, struct ad7791_state, sd);
  193. }
  194. static int ad7791_set_channel(struct ad_sigma_delta *sd, unsigned int channel)
  195. {
  196. ad_sd_set_comm(sd, channel);
  197. return 0;
  198. }
  199. static int ad7791_set_mode(struct ad_sigma_delta *sd,
  200. enum ad_sigma_delta_mode mode)
  201. {
  202. struct ad7791_state *st = ad_sigma_delta_to_ad7791(sd);
  203. switch (mode) {
  204. case AD_SD_MODE_CONTINUOUS:
  205. mode = AD7791_MODE_CONTINUOUS;
  206. break;
  207. case AD_SD_MODE_SINGLE:
  208. mode = AD7791_MODE_SINGLE;
  209. break;
  210. case AD_SD_MODE_IDLE:
  211. case AD_SD_MODE_POWERDOWN:
  212. mode = AD7791_MODE_POWERDOWN;
  213. break;
  214. }
  215. st->mode &= ~AD7791_MODE_SEL_MASK;
  216. st->mode |= AD7791_MODE_SEL(mode);
  217. return ad_sd_write_reg(sd, AD7791_REG_MODE, sizeof(st->mode), st->mode);
  218. }
  219. static const struct ad_sigma_delta_info ad7791_sigma_delta_info = {
  220. .set_channel = ad7791_set_channel,
  221. .set_mode = ad7791_set_mode,
  222. .has_registers = true,
  223. .addr_shift = 4,
  224. .read_mask = BIT(3),
  225. .irq_flags = IRQF_TRIGGER_LOW,
  226. };
  227. static int ad7791_read_raw(struct iio_dev *indio_dev,
  228. const struct iio_chan_spec *chan, int *val, int *val2, long info)
  229. {
  230. struct ad7791_state *st = iio_priv(indio_dev);
  231. bool unipolar = !!(st->mode & AD7791_MODE_UNIPOLAR);
  232. unsigned int rate;
  233. switch (info) {
  234. case IIO_CHAN_INFO_RAW:
  235. return ad_sigma_delta_single_conversion(indio_dev, chan, val);
  236. case IIO_CHAN_INFO_OFFSET:
  237. /**
  238. * Unipolar: 0 to VREF
  239. * Bipolar -VREF to VREF
  240. **/
  241. if (unipolar)
  242. *val = 0;
  243. else
  244. *val = -(1 << (chan->scan_type.realbits - 1));
  245. return IIO_VAL_INT;
  246. case IIO_CHAN_INFO_SCALE:
  247. /* The monitor channel uses an internal reference. */
  248. if (chan->address == AD7791_CH_AVDD_MONITOR) {
  249. /*
  250. * The signal is attenuated by a factor of 5 and
  251. * compared against a 1.17V internal reference.
  252. */
  253. *val = 1170 * 5;
  254. } else {
  255. int voltage_uv;
  256. voltage_uv = regulator_get_voltage(st->reg);
  257. if (voltage_uv < 0)
  258. return voltage_uv;
  259. *val = voltage_uv / 1000;
  260. }
  261. if (unipolar)
  262. *val2 = chan->scan_type.realbits;
  263. else
  264. *val2 = chan->scan_type.realbits - 1;
  265. return IIO_VAL_FRACTIONAL_LOG2;
  266. case IIO_CHAN_INFO_SAMP_FREQ:
  267. rate = st->filter & AD7791_FILTER_RATE_MASK;
  268. *val = ad7791_sample_freq_avail[rate][0];
  269. *val2 = ad7791_sample_freq_avail[rate][1];
  270. return IIO_VAL_INT_PLUS_MICRO;
  271. }
  272. return -EINVAL;
  273. }
  274. static int ad7791_write_raw(struct iio_dev *indio_dev,
  275. struct iio_chan_spec const *chan, int val, int val2, long mask)
  276. {
  277. struct ad7791_state *st = iio_priv(indio_dev);
  278. int ret, i;
  279. ret = iio_device_claim_direct_mode(indio_dev);
  280. if (ret)
  281. return ret;
  282. switch (mask) {
  283. case IIO_CHAN_INFO_SAMP_FREQ:
  284. for (i = 0; i < ARRAY_SIZE(ad7791_sample_freq_avail); i++) {
  285. if (ad7791_sample_freq_avail[i][0] == val &&
  286. ad7791_sample_freq_avail[i][1] == val2)
  287. break;
  288. }
  289. if (i == ARRAY_SIZE(ad7791_sample_freq_avail)) {
  290. ret = -EINVAL;
  291. break;
  292. }
  293. st->filter &= ~AD7791_FILTER_RATE_MASK;
  294. st->filter |= i;
  295. ad_sd_write_reg(&st->sd, AD7791_REG_FILTER,
  296. sizeof(st->filter),
  297. st->filter);
  298. break;
  299. default:
  300. ret = -EINVAL;
  301. }
  302. iio_device_release_direct_mode(indio_dev);
  303. return ret;
  304. }
  305. static IIO_CONST_ATTR_SAMP_FREQ_AVAIL("120 100 33.3 20 16.7 16.6 13.3 9.5");
  306. static struct attribute *ad7791_attributes[] = {
  307. &iio_const_attr_sampling_frequency_available.dev_attr.attr,
  308. NULL
  309. };
  310. static const struct attribute_group ad7791_attribute_group = {
  311. .attrs = ad7791_attributes,
  312. };
  313. static const struct iio_info ad7791_info = {
  314. .read_raw = &ad7791_read_raw,
  315. .write_raw = &ad7791_write_raw,
  316. .attrs = &ad7791_attribute_group,
  317. .validate_trigger = ad_sd_validate_trigger,
  318. };
  319. static const struct iio_info ad7791_no_filter_info = {
  320. .read_raw = &ad7791_read_raw,
  321. .write_raw = &ad7791_write_raw,
  322. .validate_trigger = ad_sd_validate_trigger,
  323. };
  324. static int ad7791_setup(struct ad7791_state *st,
  325. struct ad7791_platform_data *pdata)
  326. {
  327. /* Set to poweron-reset default values */
  328. st->mode = AD7791_MODE_BUFFER;
  329. st->filter = AD7791_FILTER_RATE_16_6;
  330. if (!pdata)
  331. return 0;
  332. if ((st->info->flags & AD7791_FLAG_HAS_BUFFER) && !pdata->buffered)
  333. st->mode &= ~AD7791_MODE_BUFFER;
  334. if ((st->info->flags & AD7791_FLAG_HAS_BURNOUT) &&
  335. pdata->burnout_current)
  336. st->mode |= AD7791_MODE_BURNOUT;
  337. if ((st->info->flags & AD7791_FLAG_HAS_UNIPOLAR) && pdata->unipolar)
  338. st->mode |= AD7791_MODE_UNIPOLAR;
  339. return ad_sd_write_reg(&st->sd, AD7791_REG_MODE, sizeof(st->mode),
  340. st->mode);
  341. }
  342. static int ad7791_probe(struct spi_device *spi)
  343. {
  344. struct ad7791_platform_data *pdata = spi->dev.platform_data;
  345. struct iio_dev *indio_dev;
  346. struct ad7791_state *st;
  347. int ret;
  348. if (!spi->irq) {
  349. dev_err(&spi->dev, "Missing IRQ.\n");
  350. return -ENXIO;
  351. }
  352. indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*st));
  353. if (!indio_dev)
  354. return -ENOMEM;
  355. st = iio_priv(indio_dev);
  356. st->reg = devm_regulator_get(&spi->dev, "refin");
  357. if (IS_ERR(st->reg))
  358. return PTR_ERR(st->reg);
  359. ret = regulator_enable(st->reg);
  360. if (ret)
  361. return ret;
  362. st->info = &ad7791_chip_infos[spi_get_device_id(spi)->driver_data];
  363. ad_sd_init(&st->sd, indio_dev, spi, &ad7791_sigma_delta_info);
  364. spi_set_drvdata(spi, indio_dev);
  365. indio_dev->name = spi_get_device_id(spi)->name;
  366. indio_dev->modes = INDIO_DIRECT_MODE;
  367. indio_dev->channels = st->info->channels;
  368. indio_dev->num_channels = st->info->num_channels;
  369. if (st->info->flags & AD7791_FLAG_HAS_FILTER)
  370. indio_dev->info = &ad7791_info;
  371. else
  372. indio_dev->info = &ad7791_no_filter_info;
  373. ret = ad_sd_setup_buffer_and_trigger(indio_dev);
  374. if (ret)
  375. goto error_disable_reg;
  376. ret = ad7791_setup(st, pdata);
  377. if (ret)
  378. goto error_remove_trigger;
  379. ret = iio_device_register(indio_dev);
  380. if (ret)
  381. goto error_remove_trigger;
  382. return 0;
  383. error_remove_trigger:
  384. ad_sd_cleanup_buffer_and_trigger(indio_dev);
  385. error_disable_reg:
  386. regulator_disable(st->reg);
  387. return ret;
  388. }
  389. static int ad7791_remove(struct spi_device *spi)
  390. {
  391. struct iio_dev *indio_dev = spi_get_drvdata(spi);
  392. struct ad7791_state *st = iio_priv(indio_dev);
  393. iio_device_unregister(indio_dev);
  394. ad_sd_cleanup_buffer_and_trigger(indio_dev);
  395. regulator_disable(st->reg);
  396. return 0;
  397. }
  398. static const struct spi_device_id ad7791_spi_ids[] = {
  399. { "ad7787", AD7787 },
  400. { "ad7788", AD7788 },
  401. { "ad7789", AD7789 },
  402. { "ad7790", AD7790 },
  403. { "ad7791", AD7791 },
  404. {}
  405. };
  406. MODULE_DEVICE_TABLE(spi, ad7791_spi_ids);
  407. static struct spi_driver ad7791_driver = {
  408. .driver = {
  409. .name = "ad7791",
  410. },
  411. .probe = ad7791_probe,
  412. .remove = ad7791_remove,
  413. .id_table = ad7791_spi_ids,
  414. };
  415. module_spi_driver(ad7791_driver);
  416. MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>");
  417. MODULE_DESCRIPTION("Analog Devices AD7787/AD7788/AD7789/AD7790/AD7791 ADC driver");
  418. MODULE_LICENSE("GPL v2");