ti-dac7311.c 7.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336
  1. // SPDX-License-Identifier: GPL-2.0
  2. /* ti-dac7311.c - Texas Instruments 8/10/12-bit 1-channel DAC driver
  3. *
  4. * Copyright (C) 2018 CMC NV
  5. *
  6. * https://www.ti.com/lit/ds/symlink/dac7311.pdf
  7. */
  8. #include <linux/iio/iio.h>
  9. #include <linux/module.h>
  10. #include <linux/regulator/consumer.h>
  11. #include <linux/spi/spi.h>
  12. enum {
  13. ID_DAC5311 = 0,
  14. ID_DAC6311,
  15. ID_DAC7311,
  16. };
  17. enum {
  18. POWER_1KOHM_TO_GND = 0,
  19. POWER_100KOHM_TO_GND,
  20. POWER_TRI_STATE,
  21. };
  22. struct ti_dac_spec {
  23. u8 resolution;
  24. };
  25. static const struct ti_dac_spec ti_dac_spec[] = {
  26. [ID_DAC5311] = { .resolution = 8 },
  27. [ID_DAC6311] = { .resolution = 10 },
  28. [ID_DAC7311] = { .resolution = 12 },
  29. };
  30. /**
  31. * struct ti_dac_chip - TI DAC chip
  32. * @lock: protects write sequences
  33. * @vref: regulator generating Vref
  34. * @spi: SPI device to send data to the device
  35. * @val: cached value
  36. * @powerdown: whether the chip is powered down
  37. * @powerdown_mode: selected by the user
  38. * @resolution: resolution of the chip
  39. * @buf: buffer for transfer data
  40. */
  41. struct ti_dac_chip {
  42. struct mutex lock;
  43. struct regulator *vref;
  44. struct spi_device *spi;
  45. u16 val;
  46. bool powerdown;
  47. u8 powerdown_mode;
  48. u8 resolution;
  49. u8 buf[2] ____cacheline_aligned;
  50. };
  51. static u8 ti_dac_get_power(struct ti_dac_chip *ti_dac, bool powerdown)
  52. {
  53. if (powerdown)
  54. return ti_dac->powerdown_mode + 1;
  55. return 0;
  56. }
  57. static int ti_dac_cmd(struct ti_dac_chip *ti_dac, u8 power, u16 val)
  58. {
  59. u8 shift = 14 - ti_dac->resolution;
  60. ti_dac->buf[0] = (val << shift) & 0xFF;
  61. ti_dac->buf[1] = (power << 6) | (val >> (8 - shift));
  62. return spi_write(ti_dac->spi, ti_dac->buf, 2);
  63. }
  64. static const char * const ti_dac_powerdown_modes[] = {
  65. "1kohm_to_gnd",
  66. "100kohm_to_gnd",
  67. "three_state",
  68. };
  69. static int ti_dac_get_powerdown_mode(struct iio_dev *indio_dev,
  70. const struct iio_chan_spec *chan)
  71. {
  72. struct ti_dac_chip *ti_dac = iio_priv(indio_dev);
  73. return ti_dac->powerdown_mode;
  74. }
  75. static int ti_dac_set_powerdown_mode(struct iio_dev *indio_dev,
  76. const struct iio_chan_spec *chan,
  77. unsigned int mode)
  78. {
  79. struct ti_dac_chip *ti_dac = iio_priv(indio_dev);
  80. ti_dac->powerdown_mode = mode;
  81. return 0;
  82. }
  83. static const struct iio_enum ti_dac_powerdown_mode = {
  84. .items = ti_dac_powerdown_modes,
  85. .num_items = ARRAY_SIZE(ti_dac_powerdown_modes),
  86. .get = ti_dac_get_powerdown_mode,
  87. .set = ti_dac_set_powerdown_mode,
  88. };
  89. static ssize_t ti_dac_read_powerdown(struct iio_dev *indio_dev,
  90. uintptr_t private,
  91. const struct iio_chan_spec *chan,
  92. char *buf)
  93. {
  94. struct ti_dac_chip *ti_dac = iio_priv(indio_dev);
  95. return sprintf(buf, "%d\n", ti_dac->powerdown);
  96. }
  97. static ssize_t ti_dac_write_powerdown(struct iio_dev *indio_dev,
  98. uintptr_t private,
  99. const struct iio_chan_spec *chan,
  100. const char *buf, size_t len)
  101. {
  102. struct ti_dac_chip *ti_dac = iio_priv(indio_dev);
  103. bool powerdown;
  104. u8 power;
  105. int ret;
  106. ret = strtobool(buf, &powerdown);
  107. if (ret)
  108. return ret;
  109. power = ti_dac_get_power(ti_dac, powerdown);
  110. mutex_lock(&ti_dac->lock);
  111. ret = ti_dac_cmd(ti_dac, power, 0);
  112. if (!ret)
  113. ti_dac->powerdown = powerdown;
  114. mutex_unlock(&ti_dac->lock);
  115. return ret ? ret : len;
  116. }
  117. static const struct iio_chan_spec_ext_info ti_dac_ext_info[] = {
  118. {
  119. .name = "powerdown",
  120. .read = ti_dac_read_powerdown,
  121. .write = ti_dac_write_powerdown,
  122. .shared = IIO_SHARED_BY_TYPE,
  123. },
  124. IIO_ENUM("powerdown_mode", IIO_SHARED_BY_TYPE, &ti_dac_powerdown_mode),
  125. IIO_ENUM_AVAILABLE("powerdown_mode", &ti_dac_powerdown_mode),
  126. { },
  127. };
  128. #define TI_DAC_CHANNEL(chan) { \
  129. .type = IIO_VOLTAGE, \
  130. .channel = (chan), \
  131. .output = true, \
  132. .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
  133. .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE), \
  134. .ext_info = ti_dac_ext_info, \
  135. }
  136. static const struct iio_chan_spec ti_dac_channels[] = {
  137. TI_DAC_CHANNEL(0),
  138. };
  139. static int ti_dac_read_raw(struct iio_dev *indio_dev,
  140. struct iio_chan_spec const *chan,
  141. int *val, int *val2, long mask)
  142. {
  143. struct ti_dac_chip *ti_dac = iio_priv(indio_dev);
  144. int ret;
  145. switch (mask) {
  146. case IIO_CHAN_INFO_RAW:
  147. *val = ti_dac->val;
  148. return IIO_VAL_INT;
  149. case IIO_CHAN_INFO_SCALE:
  150. ret = regulator_get_voltage(ti_dac->vref);
  151. if (ret < 0)
  152. return ret;
  153. *val = ret / 1000;
  154. *val2 = ti_dac->resolution;
  155. return IIO_VAL_FRACTIONAL_LOG2;
  156. }
  157. return -EINVAL;
  158. }
  159. static int ti_dac_write_raw(struct iio_dev *indio_dev,
  160. struct iio_chan_spec const *chan,
  161. int val, int val2, long mask)
  162. {
  163. struct ti_dac_chip *ti_dac = iio_priv(indio_dev);
  164. u8 power = ti_dac_get_power(ti_dac, ti_dac->powerdown);
  165. int ret;
  166. switch (mask) {
  167. case IIO_CHAN_INFO_RAW:
  168. if (ti_dac->val == val)
  169. return 0;
  170. if (val >= (1 << ti_dac->resolution) || val < 0)
  171. return -EINVAL;
  172. if (ti_dac->powerdown)
  173. return -EBUSY;
  174. mutex_lock(&ti_dac->lock);
  175. ret = ti_dac_cmd(ti_dac, power, val);
  176. if (!ret)
  177. ti_dac->val = val;
  178. mutex_unlock(&ti_dac->lock);
  179. break;
  180. default:
  181. ret = -EINVAL;
  182. }
  183. return ret;
  184. }
  185. static int ti_dac_write_raw_get_fmt(struct iio_dev *indio_dev,
  186. struct iio_chan_spec const *chan, long mask)
  187. {
  188. return IIO_VAL_INT;
  189. }
  190. static const struct iio_info ti_dac_info = {
  191. .read_raw = ti_dac_read_raw,
  192. .write_raw = ti_dac_write_raw,
  193. .write_raw_get_fmt = ti_dac_write_raw_get_fmt,
  194. };
  195. static int ti_dac_probe(struct spi_device *spi)
  196. {
  197. struct device *dev = &spi->dev;
  198. const struct ti_dac_spec *spec;
  199. struct ti_dac_chip *ti_dac;
  200. struct iio_dev *indio_dev;
  201. int ret;
  202. indio_dev = devm_iio_device_alloc(dev, sizeof(*ti_dac));
  203. if (!indio_dev) {
  204. dev_err(dev, "can not allocate iio device\n");
  205. return -ENOMEM;
  206. }
  207. spi->mode = SPI_MODE_1;
  208. spi->bits_per_word = 16;
  209. spi_setup(spi);
  210. indio_dev->info = &ti_dac_info;
  211. indio_dev->name = spi_get_device_id(spi)->name;
  212. indio_dev->modes = INDIO_DIRECT_MODE;
  213. indio_dev->channels = ti_dac_channels;
  214. spi_set_drvdata(spi, indio_dev);
  215. ti_dac = iio_priv(indio_dev);
  216. ti_dac->powerdown = false;
  217. ti_dac->spi = spi;
  218. spec = &ti_dac_spec[spi_get_device_id(spi)->driver_data];
  219. indio_dev->num_channels = 1;
  220. ti_dac->resolution = spec->resolution;
  221. ti_dac->vref = devm_regulator_get(dev, "vref");
  222. if (IS_ERR(ti_dac->vref)) {
  223. dev_err(dev, "error to get regulator\n");
  224. return PTR_ERR(ti_dac->vref);
  225. }
  226. ret = regulator_enable(ti_dac->vref);
  227. if (ret < 0) {
  228. dev_err(dev, "can not enable regulator\n");
  229. return ret;
  230. }
  231. mutex_init(&ti_dac->lock);
  232. ret = iio_device_register(indio_dev);
  233. if (ret) {
  234. dev_err(dev, "fail to register iio device: %d\n", ret);
  235. goto err;
  236. }
  237. return 0;
  238. err:
  239. mutex_destroy(&ti_dac->lock);
  240. regulator_disable(ti_dac->vref);
  241. return ret;
  242. }
  243. static int ti_dac_remove(struct spi_device *spi)
  244. {
  245. struct iio_dev *indio_dev = spi_get_drvdata(spi);
  246. struct ti_dac_chip *ti_dac = iio_priv(indio_dev);
  247. iio_device_unregister(indio_dev);
  248. mutex_destroy(&ti_dac->lock);
  249. regulator_disable(ti_dac->vref);
  250. return 0;
  251. }
  252. static const struct of_device_id ti_dac_of_id[] = {
  253. { .compatible = "ti,dac5311" },
  254. { .compatible = "ti,dac6311" },
  255. { .compatible = "ti,dac7311" },
  256. { }
  257. };
  258. MODULE_DEVICE_TABLE(of, ti_dac_of_id);
  259. static const struct spi_device_id ti_dac_spi_id[] = {
  260. { "dac5311", ID_DAC5311 },
  261. { "dac6311", ID_DAC6311 },
  262. { "dac7311", ID_DAC7311 },
  263. { }
  264. };
  265. MODULE_DEVICE_TABLE(spi, ti_dac_spi_id);
  266. static struct spi_driver ti_dac_driver = {
  267. .driver = {
  268. .name = "ti-dac7311",
  269. .of_match_table = ti_dac_of_id,
  270. },
  271. .probe = ti_dac_probe,
  272. .remove = ti_dac_remove,
  273. .id_table = ti_dac_spi_id,
  274. };
  275. module_spi_driver(ti_dac_driver);
  276. MODULE_AUTHOR("Charles-Antoine Couret <charles-antoine.couret@essensium.com>");
  277. MODULE_DESCRIPTION("Texas Instruments 8/10/12-bit 1-channel DAC driver");
  278. MODULE_LICENSE("GPL v2");