mcp4725.c 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * mcp4725.c - Support for Microchip MCP4725/6
  4. *
  5. * Copyright (C) 2012 Peter Meerwald <pmeerw@pmeerw.net>
  6. *
  7. * Based on max517 by Roland Stigge <stigge@antcom.de>
  8. *
  9. * driver for the Microchip I2C 12-bit digital-to-analog converter (DAC)
  10. * (7-bit I2C slave address 0x60, the three LSBs can be configured in
  11. * hardware)
  12. */
  13. #include <linux/module.h>
  14. #include <linux/i2c.h>
  15. #include <linux/err.h>
  16. #include <linux/delay.h>
  17. #include <linux/regulator/consumer.h>
  18. #include <linux/mod_devicetable.h>
  19. #include <linux/property.h>
  20. #include <linux/iio/iio.h>
  21. #include <linux/iio/sysfs.h>
  22. #include <linux/iio/dac/mcp4725.h>
  23. #define MCP4725_DRV_NAME "mcp4725"
  24. #define MCP472X_REF_VDD 0x00
  25. #define MCP472X_REF_VREF_UNBUFFERED 0x02
  26. #define MCP472X_REF_VREF_BUFFERED 0x03
  27. struct mcp4725_data {
  28. struct i2c_client *client;
  29. int id;
  30. unsigned ref_mode;
  31. bool vref_buffered;
  32. u16 dac_value;
  33. bool powerdown;
  34. unsigned powerdown_mode;
  35. struct regulator *vdd_reg;
  36. struct regulator *vref_reg;
  37. };
  38. static int __maybe_unused mcp4725_suspend(struct device *dev)
  39. {
  40. struct mcp4725_data *data = iio_priv(i2c_get_clientdata(
  41. to_i2c_client(dev)));
  42. u8 outbuf[2];
  43. outbuf[0] = (data->powerdown_mode + 1) << 4;
  44. outbuf[1] = 0;
  45. data->powerdown = true;
  46. return i2c_master_send(data->client, outbuf, 2);
  47. }
  48. static int __maybe_unused mcp4725_resume(struct device *dev)
  49. {
  50. struct mcp4725_data *data = iio_priv(i2c_get_clientdata(
  51. to_i2c_client(dev)));
  52. u8 outbuf[2];
  53. /* restore previous DAC value */
  54. outbuf[0] = (data->dac_value >> 8) & 0xf;
  55. outbuf[1] = data->dac_value & 0xff;
  56. data->powerdown = false;
  57. return i2c_master_send(data->client, outbuf, 2);
  58. }
  59. static SIMPLE_DEV_PM_OPS(mcp4725_pm_ops, mcp4725_suspend, mcp4725_resume);
  60. static ssize_t mcp4725_store_eeprom(struct device *dev,
  61. struct device_attribute *attr, const char *buf, size_t len)
  62. {
  63. struct iio_dev *indio_dev = dev_to_iio_dev(dev);
  64. struct mcp4725_data *data = iio_priv(indio_dev);
  65. int tries = 20;
  66. u8 inoutbuf[3];
  67. bool state;
  68. int ret;
  69. ret = strtobool(buf, &state);
  70. if (ret < 0)
  71. return ret;
  72. if (!state)
  73. return 0;
  74. inoutbuf[0] = 0x60; /* write EEPROM */
  75. inoutbuf[0] |= data->ref_mode << 3;
  76. inoutbuf[0] |= data->powerdown ? ((data->powerdown_mode + 1) << 1) : 0;
  77. inoutbuf[1] = data->dac_value >> 4;
  78. inoutbuf[2] = (data->dac_value & 0xf) << 4;
  79. ret = i2c_master_send(data->client, inoutbuf, 3);
  80. if (ret < 0)
  81. return ret;
  82. else if (ret != 3)
  83. return -EIO;
  84. /* wait for write complete, takes up to 50ms */
  85. while (tries--) {
  86. msleep(20);
  87. ret = i2c_master_recv(data->client, inoutbuf, 3);
  88. if (ret < 0)
  89. return ret;
  90. else if (ret != 3)
  91. return -EIO;
  92. if (inoutbuf[0] & 0x80)
  93. break;
  94. }
  95. if (tries < 0) {
  96. dev_err(&data->client->dev,
  97. "mcp4725_store_eeprom() failed, incomplete\n");
  98. return -EIO;
  99. }
  100. return len;
  101. }
  102. static IIO_DEVICE_ATTR(store_eeprom, S_IWUSR, NULL, mcp4725_store_eeprom, 0);
  103. static struct attribute *mcp4725_attributes[] = {
  104. &iio_dev_attr_store_eeprom.dev_attr.attr,
  105. NULL,
  106. };
  107. static const struct attribute_group mcp4725_attribute_group = {
  108. .attrs = mcp4725_attributes,
  109. };
  110. static const char * const mcp4725_powerdown_modes[] = {
  111. "1kohm_to_gnd",
  112. "100kohm_to_gnd",
  113. "500kohm_to_gnd"
  114. };
  115. static const char * const mcp4726_powerdown_modes[] = {
  116. "1kohm_to_gnd",
  117. "125kohm_to_gnd",
  118. "640kohm_to_gnd"
  119. };
  120. static int mcp4725_get_powerdown_mode(struct iio_dev *indio_dev,
  121. const struct iio_chan_spec *chan)
  122. {
  123. struct mcp4725_data *data = iio_priv(indio_dev);
  124. return data->powerdown_mode;
  125. }
  126. static int mcp4725_set_powerdown_mode(struct iio_dev *indio_dev,
  127. const struct iio_chan_spec *chan, unsigned mode)
  128. {
  129. struct mcp4725_data *data = iio_priv(indio_dev);
  130. data->powerdown_mode = mode;
  131. return 0;
  132. }
  133. static ssize_t mcp4725_read_powerdown(struct iio_dev *indio_dev,
  134. uintptr_t private, const struct iio_chan_spec *chan, char *buf)
  135. {
  136. struct mcp4725_data *data = iio_priv(indio_dev);
  137. return sprintf(buf, "%d\n", data->powerdown);
  138. }
  139. static ssize_t mcp4725_write_powerdown(struct iio_dev *indio_dev,
  140. uintptr_t private, const struct iio_chan_spec *chan,
  141. const char *buf, size_t len)
  142. {
  143. struct mcp4725_data *data = iio_priv(indio_dev);
  144. bool state;
  145. int ret;
  146. ret = strtobool(buf, &state);
  147. if (ret)
  148. return ret;
  149. if (state)
  150. ret = mcp4725_suspend(&data->client->dev);
  151. else
  152. ret = mcp4725_resume(&data->client->dev);
  153. if (ret < 0)
  154. return ret;
  155. return len;
  156. }
  157. enum chip_id {
  158. MCP4725,
  159. MCP4726,
  160. };
  161. static const struct iio_enum mcp472x_powerdown_mode_enum[] = {
  162. [MCP4725] = {
  163. .items = mcp4725_powerdown_modes,
  164. .num_items = ARRAY_SIZE(mcp4725_powerdown_modes),
  165. .get = mcp4725_get_powerdown_mode,
  166. .set = mcp4725_set_powerdown_mode,
  167. },
  168. [MCP4726] = {
  169. .items = mcp4726_powerdown_modes,
  170. .num_items = ARRAY_SIZE(mcp4726_powerdown_modes),
  171. .get = mcp4725_get_powerdown_mode,
  172. .set = mcp4725_set_powerdown_mode,
  173. },
  174. };
  175. static const struct iio_chan_spec_ext_info mcp4725_ext_info[] = {
  176. {
  177. .name = "powerdown",
  178. .read = mcp4725_read_powerdown,
  179. .write = mcp4725_write_powerdown,
  180. .shared = IIO_SEPARATE,
  181. },
  182. IIO_ENUM("powerdown_mode", IIO_SEPARATE,
  183. &mcp472x_powerdown_mode_enum[MCP4725]),
  184. IIO_ENUM_AVAILABLE("powerdown_mode",
  185. &mcp472x_powerdown_mode_enum[MCP4725]),
  186. { },
  187. };
  188. static const struct iio_chan_spec_ext_info mcp4726_ext_info[] = {
  189. {
  190. .name = "powerdown",
  191. .read = mcp4725_read_powerdown,
  192. .write = mcp4725_write_powerdown,
  193. .shared = IIO_SEPARATE,
  194. },
  195. IIO_ENUM("powerdown_mode", IIO_SEPARATE,
  196. &mcp472x_powerdown_mode_enum[MCP4726]),
  197. IIO_ENUM_AVAILABLE("powerdown_mode",
  198. &mcp472x_powerdown_mode_enum[MCP4726]),
  199. { },
  200. };
  201. static const struct iio_chan_spec mcp472x_channel[] = {
  202. [MCP4725] = {
  203. .type = IIO_VOLTAGE,
  204. .indexed = 1,
  205. .output = 1,
  206. .channel = 0,
  207. .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
  208. .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE),
  209. .ext_info = mcp4725_ext_info,
  210. },
  211. [MCP4726] = {
  212. .type = IIO_VOLTAGE,
  213. .indexed = 1,
  214. .output = 1,
  215. .channel = 0,
  216. .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
  217. .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE),
  218. .ext_info = mcp4726_ext_info,
  219. },
  220. };
  221. static int mcp4725_set_value(struct iio_dev *indio_dev, int val)
  222. {
  223. struct mcp4725_data *data = iio_priv(indio_dev);
  224. u8 outbuf[2];
  225. int ret;
  226. if (val >= (1 << 12) || val < 0)
  227. return -EINVAL;
  228. outbuf[0] = (val >> 8) & 0xf;
  229. outbuf[1] = val & 0xff;
  230. ret = i2c_master_send(data->client, outbuf, 2);
  231. if (ret < 0)
  232. return ret;
  233. else if (ret != 2)
  234. return -EIO;
  235. else
  236. return 0;
  237. }
  238. static int mcp4726_set_cfg(struct iio_dev *indio_dev)
  239. {
  240. struct mcp4725_data *data = iio_priv(indio_dev);
  241. u8 outbuf[3];
  242. int ret;
  243. outbuf[0] = 0x40;
  244. outbuf[0] |= data->ref_mode << 3;
  245. if (data->powerdown)
  246. outbuf[0] |= data->powerdown << 1;
  247. outbuf[1] = data->dac_value >> 4;
  248. outbuf[2] = (data->dac_value & 0xf) << 4;
  249. ret = i2c_master_send(data->client, outbuf, 3);
  250. if (ret < 0)
  251. return ret;
  252. else if (ret != 3)
  253. return -EIO;
  254. else
  255. return 0;
  256. }
  257. static int mcp4725_read_raw(struct iio_dev *indio_dev,
  258. struct iio_chan_spec const *chan,
  259. int *val, int *val2, long mask)
  260. {
  261. struct mcp4725_data *data = iio_priv(indio_dev);
  262. int ret;
  263. switch (mask) {
  264. case IIO_CHAN_INFO_RAW:
  265. *val = data->dac_value;
  266. return IIO_VAL_INT;
  267. case IIO_CHAN_INFO_SCALE:
  268. if (data->ref_mode == MCP472X_REF_VDD)
  269. ret = regulator_get_voltage(data->vdd_reg);
  270. else
  271. ret = regulator_get_voltage(data->vref_reg);
  272. if (ret < 0)
  273. return ret;
  274. *val = ret / 1000;
  275. *val2 = 12;
  276. return IIO_VAL_FRACTIONAL_LOG2;
  277. }
  278. return -EINVAL;
  279. }
  280. static int mcp4725_write_raw(struct iio_dev *indio_dev,
  281. struct iio_chan_spec const *chan,
  282. int val, int val2, long mask)
  283. {
  284. struct mcp4725_data *data = iio_priv(indio_dev);
  285. int ret;
  286. switch (mask) {
  287. case IIO_CHAN_INFO_RAW:
  288. ret = mcp4725_set_value(indio_dev, val);
  289. data->dac_value = val;
  290. break;
  291. default:
  292. ret = -EINVAL;
  293. break;
  294. }
  295. return ret;
  296. }
  297. static const struct iio_info mcp4725_info = {
  298. .read_raw = mcp4725_read_raw,
  299. .write_raw = mcp4725_write_raw,
  300. .attrs = &mcp4725_attribute_group,
  301. };
  302. static int mcp4725_probe_dt(struct device *dev,
  303. struct mcp4725_platform_data *pdata)
  304. {
  305. /* check if is the vref-supply defined */
  306. pdata->use_vref = device_property_read_bool(dev, "vref-supply");
  307. pdata->vref_buffered =
  308. device_property_read_bool(dev, "microchip,vref-buffered");
  309. return 0;
  310. }
  311. static int mcp4725_probe(struct i2c_client *client,
  312. const struct i2c_device_id *id)
  313. {
  314. struct mcp4725_data *data;
  315. struct iio_dev *indio_dev;
  316. struct mcp4725_platform_data *pdata, pdata_dt;
  317. u8 inbuf[4];
  318. u8 pd;
  319. u8 ref;
  320. int err;
  321. indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
  322. if (indio_dev == NULL)
  323. return -ENOMEM;
  324. data = iio_priv(indio_dev);
  325. i2c_set_clientdata(client, indio_dev);
  326. data->client = client;
  327. if (dev_fwnode(&client->dev))
  328. data->id = (enum chip_id)device_get_match_data(&client->dev);
  329. else
  330. data->id = id->driver_data;
  331. pdata = dev_get_platdata(&client->dev);
  332. if (!pdata) {
  333. err = mcp4725_probe_dt(&client->dev, &pdata_dt);
  334. if (err) {
  335. dev_err(&client->dev,
  336. "invalid platform or devicetree data");
  337. return err;
  338. }
  339. pdata = &pdata_dt;
  340. }
  341. if (data->id == MCP4725 && pdata->use_vref) {
  342. dev_err(&client->dev,
  343. "external reference is unavailable on MCP4725");
  344. return -EINVAL;
  345. }
  346. if (!pdata->use_vref && pdata->vref_buffered) {
  347. dev_err(&client->dev,
  348. "buffering is unavailable on the internal reference");
  349. return -EINVAL;
  350. }
  351. if (!pdata->use_vref)
  352. data->ref_mode = MCP472X_REF_VDD;
  353. else
  354. data->ref_mode = pdata->vref_buffered ?
  355. MCP472X_REF_VREF_BUFFERED :
  356. MCP472X_REF_VREF_UNBUFFERED;
  357. data->vdd_reg = devm_regulator_get(&client->dev, "vdd");
  358. if (IS_ERR(data->vdd_reg))
  359. return PTR_ERR(data->vdd_reg);
  360. err = regulator_enable(data->vdd_reg);
  361. if (err)
  362. return err;
  363. if (pdata->use_vref) {
  364. data->vref_reg = devm_regulator_get(&client->dev, "vref");
  365. if (IS_ERR(data->vref_reg)) {
  366. err = PTR_ERR(data->vref_reg);
  367. goto err_disable_vdd_reg;
  368. }
  369. err = regulator_enable(data->vref_reg);
  370. if (err)
  371. goto err_disable_vdd_reg;
  372. }
  373. indio_dev->name = id->name;
  374. indio_dev->info = &mcp4725_info;
  375. indio_dev->channels = &mcp472x_channel[id->driver_data];
  376. indio_dev->num_channels = 1;
  377. indio_dev->modes = INDIO_DIRECT_MODE;
  378. /* read current DAC value and settings */
  379. err = i2c_master_recv(client, inbuf, data->id == MCP4725 ? 3 : 4);
  380. if (err < 0) {
  381. dev_err(&client->dev, "failed to read DAC value");
  382. goto err_disable_vref_reg;
  383. }
  384. pd = (inbuf[0] >> 1) & 0x3;
  385. data->powerdown = pd > 0;
  386. data->powerdown_mode = pd ? pd - 1 : 2; /* largest resistor to gnd */
  387. data->dac_value = (inbuf[1] << 4) | (inbuf[2] >> 4);
  388. if (data->id == MCP4726)
  389. ref = (inbuf[3] >> 3) & 0x3;
  390. if (data->id == MCP4726 && ref != data->ref_mode) {
  391. dev_info(&client->dev,
  392. "voltage reference mode differs (conf: %u, eeprom: %u), setting %u",
  393. data->ref_mode, ref, data->ref_mode);
  394. err = mcp4726_set_cfg(indio_dev);
  395. if (err < 0)
  396. goto err_disable_vref_reg;
  397. }
  398. err = iio_device_register(indio_dev);
  399. if (err)
  400. goto err_disable_vref_reg;
  401. return 0;
  402. err_disable_vref_reg:
  403. if (data->vref_reg)
  404. regulator_disable(data->vref_reg);
  405. err_disable_vdd_reg:
  406. regulator_disable(data->vdd_reg);
  407. return err;
  408. }
  409. static int mcp4725_remove(struct i2c_client *client)
  410. {
  411. struct iio_dev *indio_dev = i2c_get_clientdata(client);
  412. struct mcp4725_data *data = iio_priv(indio_dev);
  413. iio_device_unregister(indio_dev);
  414. if (data->vref_reg)
  415. regulator_disable(data->vref_reg);
  416. regulator_disable(data->vdd_reg);
  417. return 0;
  418. }
  419. static const struct i2c_device_id mcp4725_id[] = {
  420. { "mcp4725", MCP4725 },
  421. { "mcp4726", MCP4726 },
  422. { }
  423. };
  424. MODULE_DEVICE_TABLE(i2c, mcp4725_id);
  425. static const struct of_device_id mcp4725_of_match[] = {
  426. {
  427. .compatible = "microchip,mcp4725",
  428. .data = (void *)MCP4725
  429. },
  430. {
  431. .compatible = "microchip,mcp4726",
  432. .data = (void *)MCP4726
  433. },
  434. { }
  435. };
  436. MODULE_DEVICE_TABLE(of, mcp4725_of_match);
  437. static struct i2c_driver mcp4725_driver = {
  438. .driver = {
  439. .name = MCP4725_DRV_NAME,
  440. .of_match_table = mcp4725_of_match,
  441. .pm = &mcp4725_pm_ops,
  442. },
  443. .probe = mcp4725_probe,
  444. .remove = mcp4725_remove,
  445. .id_table = mcp4725_id,
  446. };
  447. module_i2c_driver(mcp4725_driver);
  448. MODULE_AUTHOR("Peter Meerwald <pmeerw@pmeerw.net>");
  449. MODULE_DESCRIPTION("MCP4725/6 12-bit DAC");
  450. MODULE_LICENSE("GPL");