ad7266.c 13 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * AD7266/65 SPI ADC driver
  4. *
  5. * Copyright 2012 Analog Devices Inc.
  6. */
  7. #include <linux/device.h>
  8. #include <linux/kernel.h>
  9. #include <linux/slab.h>
  10. #include <linux/spi/spi.h>
  11. #include <linux/regulator/consumer.h>
  12. #include <linux/err.h>
  13. #include <linux/gpio/consumer.h>
  14. #include <linux/module.h>
  15. #include <linux/interrupt.h>
  16. #include <linux/iio/iio.h>
  17. #include <linux/iio/buffer.h>
  18. #include <linux/iio/trigger_consumer.h>
  19. #include <linux/iio/triggered_buffer.h>
  20. #include <linux/platform_data/ad7266.h>
  21. struct ad7266_state {
  22. struct spi_device *spi;
  23. struct regulator *reg;
  24. unsigned long vref_mv;
  25. struct spi_transfer single_xfer[3];
  26. struct spi_message single_msg;
  27. enum ad7266_range range;
  28. enum ad7266_mode mode;
  29. bool fixed_addr;
  30. struct gpio_desc *gpios[3];
  31. /*
  32. * DMA (thus cache coherency maintenance) requires the
  33. * transfer buffers to live in their own cache lines.
  34. * The buffer needs to be large enough to hold two samples (4 bytes) and
  35. * the naturally aligned timestamp (8 bytes).
  36. */
  37. struct {
  38. __be16 sample[2];
  39. s64 timestamp;
  40. } data ____cacheline_aligned;
  41. };
  42. static int ad7266_wakeup(struct ad7266_state *st)
  43. {
  44. /* Any read with >= 2 bytes will wake the device */
  45. return spi_read(st->spi, &st->data.sample[0], 2);
  46. }
  47. static int ad7266_powerdown(struct ad7266_state *st)
  48. {
  49. /* Any read with < 2 bytes will powerdown the device */
  50. return spi_read(st->spi, &st->data.sample[0], 1);
  51. }
  52. static int ad7266_preenable(struct iio_dev *indio_dev)
  53. {
  54. struct ad7266_state *st = iio_priv(indio_dev);
  55. return ad7266_wakeup(st);
  56. }
  57. static int ad7266_postdisable(struct iio_dev *indio_dev)
  58. {
  59. struct ad7266_state *st = iio_priv(indio_dev);
  60. return ad7266_powerdown(st);
  61. }
  62. static const struct iio_buffer_setup_ops iio_triggered_buffer_setup_ops = {
  63. .preenable = &ad7266_preenable,
  64. .postdisable = &ad7266_postdisable,
  65. };
  66. static irqreturn_t ad7266_trigger_handler(int irq, void *p)
  67. {
  68. struct iio_poll_func *pf = p;
  69. struct iio_dev *indio_dev = pf->indio_dev;
  70. struct ad7266_state *st = iio_priv(indio_dev);
  71. int ret;
  72. ret = spi_read(st->spi, st->data.sample, 4);
  73. if (ret == 0) {
  74. iio_push_to_buffers_with_timestamp(indio_dev, &st->data,
  75. pf->timestamp);
  76. }
  77. iio_trigger_notify_done(indio_dev->trig);
  78. return IRQ_HANDLED;
  79. }
  80. static void ad7266_select_input(struct ad7266_state *st, unsigned int nr)
  81. {
  82. unsigned int i;
  83. if (st->fixed_addr)
  84. return;
  85. switch (st->mode) {
  86. case AD7266_MODE_SINGLE_ENDED:
  87. nr >>= 1;
  88. break;
  89. case AD7266_MODE_PSEUDO_DIFF:
  90. nr |= 1;
  91. break;
  92. case AD7266_MODE_DIFF:
  93. nr &= ~1;
  94. break;
  95. }
  96. for (i = 0; i < 3; ++i)
  97. gpiod_set_value(st->gpios[i], (bool)(nr & BIT(i)));
  98. }
  99. static int ad7266_update_scan_mode(struct iio_dev *indio_dev,
  100. const unsigned long *scan_mask)
  101. {
  102. struct ad7266_state *st = iio_priv(indio_dev);
  103. unsigned int nr = find_first_bit(scan_mask, indio_dev->masklength);
  104. ad7266_select_input(st, nr);
  105. return 0;
  106. }
  107. static int ad7266_read_single(struct ad7266_state *st, int *val,
  108. unsigned int address)
  109. {
  110. int ret;
  111. ad7266_select_input(st, address);
  112. ret = spi_sync(st->spi, &st->single_msg);
  113. *val = be16_to_cpu(st->data.sample[address % 2]);
  114. return ret;
  115. }
  116. static int ad7266_read_raw(struct iio_dev *indio_dev,
  117. struct iio_chan_spec const *chan, int *val, int *val2, long m)
  118. {
  119. struct ad7266_state *st = iio_priv(indio_dev);
  120. unsigned long scale_mv;
  121. int ret;
  122. switch (m) {
  123. case IIO_CHAN_INFO_RAW:
  124. ret = iio_device_claim_direct_mode(indio_dev);
  125. if (ret)
  126. return ret;
  127. ret = ad7266_read_single(st, val, chan->address);
  128. iio_device_release_direct_mode(indio_dev);
  129. *val = (*val >> 2) & 0xfff;
  130. if (chan->scan_type.sign == 's')
  131. *val = sign_extend32(*val, 11);
  132. return IIO_VAL_INT;
  133. case IIO_CHAN_INFO_SCALE:
  134. scale_mv = st->vref_mv;
  135. if (st->mode == AD7266_MODE_DIFF)
  136. scale_mv *= 2;
  137. if (st->range == AD7266_RANGE_2VREF)
  138. scale_mv *= 2;
  139. *val = scale_mv;
  140. *val2 = chan->scan_type.realbits;
  141. return IIO_VAL_FRACTIONAL_LOG2;
  142. case IIO_CHAN_INFO_OFFSET:
  143. if (st->range == AD7266_RANGE_2VREF &&
  144. st->mode != AD7266_MODE_DIFF)
  145. *val = 2048;
  146. else
  147. *val = 0;
  148. return IIO_VAL_INT;
  149. }
  150. return -EINVAL;
  151. }
  152. #define AD7266_CHAN(_chan, _sign) { \
  153. .type = IIO_VOLTAGE, \
  154. .indexed = 1, \
  155. .channel = (_chan), \
  156. .address = (_chan), \
  157. .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
  158. .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) \
  159. | BIT(IIO_CHAN_INFO_OFFSET), \
  160. .scan_index = (_chan), \
  161. .scan_type = { \
  162. .sign = (_sign), \
  163. .realbits = 12, \
  164. .storagebits = 16, \
  165. .shift = 2, \
  166. .endianness = IIO_BE, \
  167. }, \
  168. }
  169. #define AD7266_DECLARE_SINGLE_ENDED_CHANNELS(_name, _sign) \
  170. const struct iio_chan_spec ad7266_channels_##_name[] = { \
  171. AD7266_CHAN(0, (_sign)), \
  172. AD7266_CHAN(1, (_sign)), \
  173. AD7266_CHAN(2, (_sign)), \
  174. AD7266_CHAN(3, (_sign)), \
  175. AD7266_CHAN(4, (_sign)), \
  176. AD7266_CHAN(5, (_sign)), \
  177. AD7266_CHAN(6, (_sign)), \
  178. AD7266_CHAN(7, (_sign)), \
  179. AD7266_CHAN(8, (_sign)), \
  180. AD7266_CHAN(9, (_sign)), \
  181. AD7266_CHAN(10, (_sign)), \
  182. AD7266_CHAN(11, (_sign)), \
  183. IIO_CHAN_SOFT_TIMESTAMP(13), \
  184. }
  185. #define AD7266_DECLARE_SINGLE_ENDED_CHANNELS_FIXED(_name, _sign) \
  186. const struct iio_chan_spec ad7266_channels_##_name##_fixed[] = { \
  187. AD7266_CHAN(0, (_sign)), \
  188. AD7266_CHAN(1, (_sign)), \
  189. IIO_CHAN_SOFT_TIMESTAMP(2), \
  190. }
  191. static AD7266_DECLARE_SINGLE_ENDED_CHANNELS(u, 'u');
  192. static AD7266_DECLARE_SINGLE_ENDED_CHANNELS(s, 's');
  193. static AD7266_DECLARE_SINGLE_ENDED_CHANNELS_FIXED(u, 'u');
  194. static AD7266_DECLARE_SINGLE_ENDED_CHANNELS_FIXED(s, 's');
  195. #define AD7266_CHAN_DIFF(_chan, _sign) { \
  196. .type = IIO_VOLTAGE, \
  197. .indexed = 1, \
  198. .channel = (_chan) * 2, \
  199. .channel2 = (_chan) * 2 + 1, \
  200. .address = (_chan), \
  201. .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
  202. .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) \
  203. | BIT(IIO_CHAN_INFO_OFFSET), \
  204. .scan_index = (_chan), \
  205. .scan_type = { \
  206. .sign = _sign, \
  207. .realbits = 12, \
  208. .storagebits = 16, \
  209. .shift = 2, \
  210. .endianness = IIO_BE, \
  211. }, \
  212. .differential = 1, \
  213. }
  214. #define AD7266_DECLARE_DIFF_CHANNELS(_name, _sign) \
  215. const struct iio_chan_spec ad7266_channels_diff_##_name[] = { \
  216. AD7266_CHAN_DIFF(0, (_sign)), \
  217. AD7266_CHAN_DIFF(1, (_sign)), \
  218. AD7266_CHAN_DIFF(2, (_sign)), \
  219. AD7266_CHAN_DIFF(3, (_sign)), \
  220. AD7266_CHAN_DIFF(4, (_sign)), \
  221. AD7266_CHAN_DIFF(5, (_sign)), \
  222. IIO_CHAN_SOFT_TIMESTAMP(6), \
  223. }
  224. static AD7266_DECLARE_DIFF_CHANNELS(s, 's');
  225. static AD7266_DECLARE_DIFF_CHANNELS(u, 'u');
  226. #define AD7266_DECLARE_DIFF_CHANNELS_FIXED(_name, _sign) \
  227. const struct iio_chan_spec ad7266_channels_diff_fixed_##_name[] = { \
  228. AD7266_CHAN_DIFF(0, (_sign)), \
  229. AD7266_CHAN_DIFF(1, (_sign)), \
  230. IIO_CHAN_SOFT_TIMESTAMP(2), \
  231. }
  232. static AD7266_DECLARE_DIFF_CHANNELS_FIXED(s, 's');
  233. static AD7266_DECLARE_DIFF_CHANNELS_FIXED(u, 'u');
  234. static const struct iio_info ad7266_info = {
  235. .read_raw = &ad7266_read_raw,
  236. .update_scan_mode = &ad7266_update_scan_mode,
  237. };
  238. static const unsigned long ad7266_available_scan_masks[] = {
  239. 0x003,
  240. 0x00c,
  241. 0x030,
  242. 0x0c0,
  243. 0x300,
  244. 0xc00,
  245. 0x000,
  246. };
  247. static const unsigned long ad7266_available_scan_masks_diff[] = {
  248. 0x003,
  249. 0x00c,
  250. 0x030,
  251. 0x000,
  252. };
  253. static const unsigned long ad7266_available_scan_masks_fixed[] = {
  254. 0x003,
  255. 0x000,
  256. };
  257. struct ad7266_chan_info {
  258. const struct iio_chan_spec *channels;
  259. unsigned int num_channels;
  260. const unsigned long *scan_masks;
  261. };
  262. #define AD7266_CHAN_INFO_INDEX(_differential, _signed, _fixed) \
  263. (((_differential) << 2) | ((_signed) << 1) | ((_fixed) << 0))
  264. static const struct ad7266_chan_info ad7266_chan_infos[] = {
  265. [AD7266_CHAN_INFO_INDEX(0, 0, 0)] = {
  266. .channels = ad7266_channels_u,
  267. .num_channels = ARRAY_SIZE(ad7266_channels_u),
  268. .scan_masks = ad7266_available_scan_masks,
  269. },
  270. [AD7266_CHAN_INFO_INDEX(0, 0, 1)] = {
  271. .channels = ad7266_channels_u_fixed,
  272. .num_channels = ARRAY_SIZE(ad7266_channels_u_fixed),
  273. .scan_masks = ad7266_available_scan_masks_fixed,
  274. },
  275. [AD7266_CHAN_INFO_INDEX(0, 1, 0)] = {
  276. .channels = ad7266_channels_s,
  277. .num_channels = ARRAY_SIZE(ad7266_channels_s),
  278. .scan_masks = ad7266_available_scan_masks,
  279. },
  280. [AD7266_CHAN_INFO_INDEX(0, 1, 1)] = {
  281. .channels = ad7266_channels_s_fixed,
  282. .num_channels = ARRAY_SIZE(ad7266_channels_s_fixed),
  283. .scan_masks = ad7266_available_scan_masks_fixed,
  284. },
  285. [AD7266_CHAN_INFO_INDEX(1, 0, 0)] = {
  286. .channels = ad7266_channels_diff_u,
  287. .num_channels = ARRAY_SIZE(ad7266_channels_diff_u),
  288. .scan_masks = ad7266_available_scan_masks_diff,
  289. },
  290. [AD7266_CHAN_INFO_INDEX(1, 0, 1)] = {
  291. .channels = ad7266_channels_diff_fixed_u,
  292. .num_channels = ARRAY_SIZE(ad7266_channels_diff_fixed_u),
  293. .scan_masks = ad7266_available_scan_masks_fixed,
  294. },
  295. [AD7266_CHAN_INFO_INDEX(1, 1, 0)] = {
  296. .channels = ad7266_channels_diff_s,
  297. .num_channels = ARRAY_SIZE(ad7266_channels_diff_s),
  298. .scan_masks = ad7266_available_scan_masks_diff,
  299. },
  300. [AD7266_CHAN_INFO_INDEX(1, 1, 1)] = {
  301. .channels = ad7266_channels_diff_fixed_s,
  302. .num_channels = ARRAY_SIZE(ad7266_channels_diff_fixed_s),
  303. .scan_masks = ad7266_available_scan_masks_fixed,
  304. },
  305. };
  306. static void ad7266_init_channels(struct iio_dev *indio_dev)
  307. {
  308. struct ad7266_state *st = iio_priv(indio_dev);
  309. bool is_differential, is_signed;
  310. const struct ad7266_chan_info *chan_info;
  311. int i;
  312. is_differential = st->mode != AD7266_MODE_SINGLE_ENDED;
  313. is_signed = (st->range == AD7266_RANGE_2VREF) |
  314. (st->mode == AD7266_MODE_DIFF);
  315. i = AD7266_CHAN_INFO_INDEX(is_differential, is_signed, st->fixed_addr);
  316. chan_info = &ad7266_chan_infos[i];
  317. indio_dev->channels = chan_info->channels;
  318. indio_dev->num_channels = chan_info->num_channels;
  319. indio_dev->available_scan_masks = chan_info->scan_masks;
  320. indio_dev->masklength = chan_info->num_channels - 1;
  321. }
  322. static const char * const ad7266_gpio_labels[] = {
  323. "ad0", "ad1", "ad2",
  324. };
  325. static int ad7266_probe(struct spi_device *spi)
  326. {
  327. struct ad7266_platform_data *pdata = spi->dev.platform_data;
  328. struct iio_dev *indio_dev;
  329. struct ad7266_state *st;
  330. unsigned int i;
  331. int ret;
  332. indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*st));
  333. if (indio_dev == NULL)
  334. return -ENOMEM;
  335. st = iio_priv(indio_dev);
  336. st->reg = devm_regulator_get_optional(&spi->dev, "vref");
  337. if (!IS_ERR(st->reg)) {
  338. ret = regulator_enable(st->reg);
  339. if (ret)
  340. return ret;
  341. ret = regulator_get_voltage(st->reg);
  342. if (ret < 0)
  343. goto error_disable_reg;
  344. st->vref_mv = ret / 1000;
  345. } else {
  346. /* Any other error indicates that the regulator does exist */
  347. if (PTR_ERR(st->reg) != -ENODEV)
  348. return PTR_ERR(st->reg);
  349. /* Use internal reference */
  350. st->vref_mv = 2500;
  351. }
  352. if (pdata) {
  353. st->fixed_addr = pdata->fixed_addr;
  354. st->mode = pdata->mode;
  355. st->range = pdata->range;
  356. if (!st->fixed_addr) {
  357. for (i = 0; i < ARRAY_SIZE(st->gpios); ++i) {
  358. st->gpios[i] = devm_gpiod_get(&spi->dev,
  359. ad7266_gpio_labels[i],
  360. GPIOD_OUT_LOW);
  361. if (IS_ERR(st->gpios[i])) {
  362. ret = PTR_ERR(st->gpios[i]);
  363. goto error_disable_reg;
  364. }
  365. }
  366. }
  367. } else {
  368. st->fixed_addr = true;
  369. st->range = AD7266_RANGE_VREF;
  370. st->mode = AD7266_MODE_DIFF;
  371. }
  372. spi_set_drvdata(spi, indio_dev);
  373. st->spi = spi;
  374. indio_dev->name = spi_get_device_id(spi)->name;
  375. indio_dev->modes = INDIO_DIRECT_MODE;
  376. indio_dev->info = &ad7266_info;
  377. ad7266_init_channels(indio_dev);
  378. /* wakeup */
  379. st->single_xfer[0].rx_buf = &st->data.sample[0];
  380. st->single_xfer[0].len = 2;
  381. st->single_xfer[0].cs_change = 1;
  382. /* conversion */
  383. st->single_xfer[1].rx_buf = st->data.sample;
  384. st->single_xfer[1].len = 4;
  385. st->single_xfer[1].cs_change = 1;
  386. /* powerdown */
  387. st->single_xfer[2].tx_buf = &st->data.sample[0];
  388. st->single_xfer[2].len = 1;
  389. spi_message_init(&st->single_msg);
  390. spi_message_add_tail(&st->single_xfer[0], &st->single_msg);
  391. spi_message_add_tail(&st->single_xfer[1], &st->single_msg);
  392. spi_message_add_tail(&st->single_xfer[2], &st->single_msg);
  393. ret = iio_triggered_buffer_setup(indio_dev, &iio_pollfunc_store_time,
  394. &ad7266_trigger_handler, &iio_triggered_buffer_setup_ops);
  395. if (ret)
  396. goto error_disable_reg;
  397. ret = iio_device_register(indio_dev);
  398. if (ret)
  399. goto error_buffer_cleanup;
  400. return 0;
  401. error_buffer_cleanup:
  402. iio_triggered_buffer_cleanup(indio_dev);
  403. error_disable_reg:
  404. if (!IS_ERR(st->reg))
  405. regulator_disable(st->reg);
  406. return ret;
  407. }
  408. static int ad7266_remove(struct spi_device *spi)
  409. {
  410. struct iio_dev *indio_dev = spi_get_drvdata(spi);
  411. struct ad7266_state *st = iio_priv(indio_dev);
  412. iio_device_unregister(indio_dev);
  413. iio_triggered_buffer_cleanup(indio_dev);
  414. if (!IS_ERR(st->reg))
  415. regulator_disable(st->reg);
  416. return 0;
  417. }
  418. static const struct spi_device_id ad7266_id[] = {
  419. {"ad7265", 0},
  420. {"ad7266", 0},
  421. { }
  422. };
  423. MODULE_DEVICE_TABLE(spi, ad7266_id);
  424. static struct spi_driver ad7266_driver = {
  425. .driver = {
  426. .name = "ad7266",
  427. },
  428. .probe = ad7266_probe,
  429. .remove = ad7266_remove,
  430. .id_table = ad7266_id,
  431. };
  432. module_spi_driver(ad7266_driver);
  433. MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>");
  434. MODULE_DESCRIPTION("Analog Devices AD7266/65 ADC");
  435. MODULE_LICENSE("GPL v2");