mcp4725.c 8.1 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358
  1. /*
  2. * mcp4725.c - Support for Microchip MCP4725
  3. *
  4. * Copyright (C) 2012 Peter Meerwald <pmeerw@pmeerw.net>
  5. *
  6. * Based on max517 by Roland Stigge <stigge@antcom.de>
  7. *
  8. * This file is subject to the terms and conditions of version 2 of
  9. * the GNU General Public License. See the file COPYING in the main
  10. * directory of this archive for more details.
  11. *
  12. * driver for the Microchip I2C 12-bit digital-to-analog converter (DAC)
  13. * (7-bit I2C slave address 0x60, the three LSBs can be configured in
  14. * hardware)
  15. */
  16. #include <linux/module.h>
  17. #include <linux/init.h>
  18. #include <linux/i2c.h>
  19. #include <linux/err.h>
  20. #include <linux/delay.h>
  21. #include <linux/iio/iio.h>
  22. #include <linux/iio/sysfs.h>
  23. #include <linux/iio/dac/mcp4725.h>
  24. #define MCP4725_DRV_NAME "mcp4725"
  25. struct mcp4725_data {
  26. struct i2c_client *client;
  27. u16 vref_mv;
  28. u16 dac_value;
  29. bool powerdown;
  30. unsigned powerdown_mode;
  31. };
  32. static int mcp4725_suspend(struct device *dev)
  33. {
  34. struct mcp4725_data *data = iio_priv(i2c_get_clientdata(
  35. to_i2c_client(dev)));
  36. u8 outbuf[2];
  37. outbuf[0] = (data->powerdown_mode + 1) << 4;
  38. outbuf[1] = 0;
  39. data->powerdown = true;
  40. return i2c_master_send(data->client, outbuf, 2);
  41. }
  42. static int mcp4725_resume(struct device *dev)
  43. {
  44. struct mcp4725_data *data = iio_priv(i2c_get_clientdata(
  45. to_i2c_client(dev)));
  46. u8 outbuf[2];
  47. /* restore previous DAC value */
  48. outbuf[0] = (data->dac_value >> 8) & 0xf;
  49. outbuf[1] = data->dac_value & 0xff;
  50. data->powerdown = false;
  51. return i2c_master_send(data->client, outbuf, 2);
  52. }
  53. #ifdef CONFIG_PM_SLEEP
  54. static SIMPLE_DEV_PM_OPS(mcp4725_pm_ops, mcp4725_suspend, mcp4725_resume);
  55. #define MCP4725_PM_OPS (&mcp4725_pm_ops)
  56. #else
  57. #define MCP4725_PM_OPS NULL
  58. #endif
  59. static ssize_t mcp4725_store_eeprom(struct device *dev,
  60. struct device_attribute *attr, const char *buf, size_t len)
  61. {
  62. struct iio_dev *indio_dev = dev_to_iio_dev(dev);
  63. struct mcp4725_data *data = iio_priv(indio_dev);
  64. int tries = 20;
  65. u8 inoutbuf[3];
  66. bool state;
  67. int ret;
  68. ret = strtobool(buf, &state);
  69. if (ret < 0)
  70. return ret;
  71. if (!state)
  72. return 0;
  73. inoutbuf[0] = 0x60; /* write EEPROM */
  74. inoutbuf[1] = data->dac_value >> 4;
  75. inoutbuf[2] = (data->dac_value & 0xf) << 4;
  76. ret = i2c_master_send(data->client, inoutbuf, 3);
  77. if (ret < 0)
  78. return ret;
  79. else if (ret != 3)
  80. return -EIO;
  81. /* wait for write complete, takes up to 50ms */
  82. while (tries--) {
  83. msleep(20);
  84. ret = i2c_master_recv(data->client, inoutbuf, 3);
  85. if (ret < 0)
  86. return ret;
  87. else if (ret != 3)
  88. return -EIO;
  89. if (inoutbuf[0] & 0x80)
  90. break;
  91. }
  92. if (tries < 0) {
  93. dev_err(&data->client->dev,
  94. "mcp4725_store_eeprom() failed, incomplete\n");
  95. return -EIO;
  96. }
  97. return len;
  98. }
  99. static IIO_DEVICE_ATTR(store_eeprom, S_IWUSR, NULL, mcp4725_store_eeprom, 0);
  100. static struct attribute *mcp4725_attributes[] = {
  101. &iio_dev_attr_store_eeprom.dev_attr.attr,
  102. NULL,
  103. };
  104. static const struct attribute_group mcp4725_attribute_group = {
  105. .attrs = mcp4725_attributes,
  106. };
  107. static const char * const mcp4725_powerdown_modes[] = {
  108. "1kohm_to_gnd",
  109. "100kohm_to_gnd",
  110. "500kohm_to_gnd"
  111. };
  112. static int mcp4725_get_powerdown_mode(struct iio_dev *indio_dev,
  113. const struct iio_chan_spec *chan)
  114. {
  115. struct mcp4725_data *data = iio_priv(indio_dev);
  116. return data->powerdown_mode;
  117. }
  118. static int mcp4725_set_powerdown_mode(struct iio_dev *indio_dev,
  119. const struct iio_chan_spec *chan, unsigned mode)
  120. {
  121. struct mcp4725_data *data = iio_priv(indio_dev);
  122. data->powerdown_mode = mode;
  123. return 0;
  124. }
  125. static ssize_t mcp4725_read_powerdown(struct iio_dev *indio_dev,
  126. uintptr_t private, const struct iio_chan_spec *chan, char *buf)
  127. {
  128. struct mcp4725_data *data = iio_priv(indio_dev);
  129. return sprintf(buf, "%d\n", data->powerdown);
  130. }
  131. static ssize_t mcp4725_write_powerdown(struct iio_dev *indio_dev,
  132. uintptr_t private, const struct iio_chan_spec *chan,
  133. const char *buf, size_t len)
  134. {
  135. struct mcp4725_data *data = iio_priv(indio_dev);
  136. bool state;
  137. int ret;
  138. ret = strtobool(buf, &state);
  139. if (ret)
  140. return ret;
  141. if (state)
  142. ret = mcp4725_suspend(&data->client->dev);
  143. else
  144. ret = mcp4725_resume(&data->client->dev);
  145. if (ret < 0)
  146. return ret;
  147. return len;
  148. }
  149. static const struct iio_enum mcp4725_powerdown_mode_enum = {
  150. .items = mcp4725_powerdown_modes,
  151. .num_items = ARRAY_SIZE(mcp4725_powerdown_modes),
  152. .get = mcp4725_get_powerdown_mode,
  153. .set = mcp4725_set_powerdown_mode,
  154. };
  155. static const struct iio_chan_spec_ext_info mcp4725_ext_info[] = {
  156. {
  157. .name = "powerdown",
  158. .read = mcp4725_read_powerdown,
  159. .write = mcp4725_write_powerdown,
  160. },
  161. IIO_ENUM("powerdown_mode", false, &mcp4725_powerdown_mode_enum),
  162. IIO_ENUM_AVAILABLE("powerdown_mode", &mcp4725_powerdown_mode_enum),
  163. { },
  164. };
  165. static const struct iio_chan_spec mcp4725_channel = {
  166. .type = IIO_VOLTAGE,
  167. .indexed = 1,
  168. .output = 1,
  169. .channel = 0,
  170. .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
  171. .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE),
  172. .scan_type = IIO_ST('u', 12, 16, 0),
  173. .ext_info = mcp4725_ext_info,
  174. };
  175. static int mcp4725_set_value(struct iio_dev *indio_dev, int val)
  176. {
  177. struct mcp4725_data *data = iio_priv(indio_dev);
  178. u8 outbuf[2];
  179. int ret;
  180. if (val >= (1 << 12) || val < 0)
  181. return -EINVAL;
  182. outbuf[0] = (val >> 8) & 0xf;
  183. outbuf[1] = val & 0xff;
  184. ret = i2c_master_send(data->client, outbuf, 2);
  185. if (ret < 0)
  186. return ret;
  187. else if (ret != 2)
  188. return -EIO;
  189. else
  190. return 0;
  191. }
  192. static int mcp4725_read_raw(struct iio_dev *indio_dev,
  193. struct iio_chan_spec const *chan,
  194. int *val, int *val2, long mask)
  195. {
  196. struct mcp4725_data *data = iio_priv(indio_dev);
  197. unsigned long scale_uv;
  198. switch (mask) {
  199. case IIO_CHAN_INFO_RAW:
  200. *val = data->dac_value;
  201. return IIO_VAL_INT;
  202. case IIO_CHAN_INFO_SCALE:
  203. scale_uv = (data->vref_mv * 1000) >> 12;
  204. *val = scale_uv / 1000000;
  205. *val2 = scale_uv % 1000000;
  206. return IIO_VAL_INT_PLUS_MICRO;
  207. }
  208. return -EINVAL;
  209. }
  210. static int mcp4725_write_raw(struct iio_dev *indio_dev,
  211. struct iio_chan_spec const *chan,
  212. int val, int val2, long mask)
  213. {
  214. struct mcp4725_data *data = iio_priv(indio_dev);
  215. int ret;
  216. switch (mask) {
  217. case IIO_CHAN_INFO_RAW:
  218. ret = mcp4725_set_value(indio_dev, val);
  219. data->dac_value = val;
  220. break;
  221. default:
  222. ret = -EINVAL;
  223. break;
  224. }
  225. return ret;
  226. }
  227. static const struct iio_info mcp4725_info = {
  228. .read_raw = mcp4725_read_raw,
  229. .write_raw = mcp4725_write_raw,
  230. .attrs = &mcp4725_attribute_group,
  231. .driver_module = THIS_MODULE,
  232. };
  233. static int mcp4725_probe(struct i2c_client *client,
  234. const struct i2c_device_id *id)
  235. {
  236. struct mcp4725_data *data;
  237. struct iio_dev *indio_dev;
  238. struct mcp4725_platform_data *platform_data = client->dev.platform_data;
  239. u8 inbuf[3];
  240. u8 pd;
  241. int err;
  242. if (!platform_data || !platform_data->vref_mv) {
  243. dev_err(&client->dev, "invalid platform data");
  244. return -EINVAL;
  245. }
  246. indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
  247. if (indio_dev == NULL)
  248. return -ENOMEM;
  249. data = iio_priv(indio_dev);
  250. i2c_set_clientdata(client, indio_dev);
  251. data->client = client;
  252. indio_dev->dev.parent = &client->dev;
  253. indio_dev->info = &mcp4725_info;
  254. indio_dev->channels = &mcp4725_channel;
  255. indio_dev->num_channels = 1;
  256. indio_dev->modes = INDIO_DIRECT_MODE;
  257. data->vref_mv = platform_data->vref_mv;
  258. /* read current DAC value */
  259. err = i2c_master_recv(client, inbuf, 3);
  260. if (err < 0) {
  261. dev_err(&client->dev, "failed to read DAC value");
  262. return err;
  263. }
  264. pd = (inbuf[0] >> 1) & 0x3;
  265. data->powerdown = pd > 0 ? true : false;
  266. data->powerdown_mode = pd ? pd-1 : 2; /* 500kohm_to_gnd */
  267. data->dac_value = (inbuf[1] << 4) | (inbuf[2] >> 4);
  268. err = iio_device_register(indio_dev);
  269. if (err)
  270. return err;
  271. dev_info(&client->dev, "MCP4725 DAC registered\n");
  272. return 0;
  273. }
  274. static int mcp4725_remove(struct i2c_client *client)
  275. {
  276. iio_device_unregister(i2c_get_clientdata(client));
  277. return 0;
  278. }
  279. static const struct i2c_device_id mcp4725_id[] = {
  280. { "mcp4725", 0 },
  281. { }
  282. };
  283. MODULE_DEVICE_TABLE(i2c, mcp4725_id);
  284. static struct i2c_driver mcp4725_driver = {
  285. .driver = {
  286. .name = MCP4725_DRV_NAME,
  287. .pm = MCP4725_PM_OPS,
  288. },
  289. .probe = mcp4725_probe,
  290. .remove = mcp4725_remove,
  291. .id_table = mcp4725_id,
  292. };
  293. module_i2c_driver(mcp4725_driver);
  294. MODULE_AUTHOR("Peter Meerwald <pmeerw@pmeerw.net>");
  295. MODULE_DESCRIPTION("MCP4725 12-bit DAC");
  296. MODULE_LICENSE("GPL");