ad5446.c 14 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614
  1. /*
  2. * AD5446 SPI DAC driver
  3. *
  4. * Copyright 2010 Analog Devices Inc.
  5. *
  6. * Licensed under the GPL-2 or later.
  7. */
  8. #include <linux/interrupt.h>
  9. #include <linux/workqueue.h>
  10. #include <linux/device.h>
  11. #include <linux/kernel.h>
  12. #include <linux/slab.h>
  13. #include <linux/sysfs.h>
  14. #include <linux/list.h>
  15. #include <linux/spi/spi.h>
  16. #include <linux/i2c.h>
  17. #include <linux/regulator/consumer.h>
  18. #include <linux/err.h>
  19. #include <linux/module.h>
  20. #include <linux/iio/iio.h>
  21. #include <linux/iio/sysfs.h>
  22. #define MODE_PWRDWN_1k 0x1
  23. #define MODE_PWRDWN_100k 0x2
  24. #define MODE_PWRDWN_TRISTATE 0x3
  25. /**
  26. * struct ad5446_state - driver instance specific data
  27. * @spi: spi_device
  28. * @chip_info: chip model specific constants, available modes etc
  29. * @reg: supply regulator
  30. * @vref_mv: actual reference voltage used
  31. */
  32. struct ad5446_state {
  33. struct device *dev;
  34. const struct ad5446_chip_info *chip_info;
  35. struct regulator *reg;
  36. unsigned short vref_mv;
  37. unsigned cached_val;
  38. unsigned pwr_down_mode;
  39. unsigned pwr_down;
  40. };
  41. /**
  42. * struct ad5446_chip_info - chip specific information
  43. * @channel: channel spec for the DAC
  44. * @int_vref_mv: AD5620/40/60: the internal reference voltage
  45. * @write: chip specific helper function to write to the register
  46. */
  47. struct ad5446_chip_info {
  48. struct iio_chan_spec channel;
  49. u16 int_vref_mv;
  50. int (*write)(struct ad5446_state *st, unsigned val);
  51. };
  52. static const char * const ad5446_powerdown_modes[] = {
  53. "1kohm_to_gnd", "100kohm_to_gnd", "three_state"
  54. };
  55. static int ad5446_set_powerdown_mode(struct iio_dev *indio_dev,
  56. const struct iio_chan_spec *chan, unsigned int mode)
  57. {
  58. struct ad5446_state *st = iio_priv(indio_dev);
  59. st->pwr_down_mode = mode + 1;
  60. return 0;
  61. }
  62. static int ad5446_get_powerdown_mode(struct iio_dev *indio_dev,
  63. const struct iio_chan_spec *chan)
  64. {
  65. struct ad5446_state *st = iio_priv(indio_dev);
  66. return st->pwr_down_mode - 1;
  67. }
  68. static const struct iio_enum ad5446_powerdown_mode_enum = {
  69. .items = ad5446_powerdown_modes,
  70. .num_items = ARRAY_SIZE(ad5446_powerdown_modes),
  71. .get = ad5446_get_powerdown_mode,
  72. .set = ad5446_set_powerdown_mode,
  73. };
  74. static ssize_t ad5446_read_dac_powerdown(struct iio_dev *indio_dev,
  75. uintptr_t private,
  76. const struct iio_chan_spec *chan,
  77. char *buf)
  78. {
  79. struct ad5446_state *st = iio_priv(indio_dev);
  80. return sprintf(buf, "%d\n", st->pwr_down);
  81. }
  82. static ssize_t ad5446_write_dac_powerdown(struct iio_dev *indio_dev,
  83. uintptr_t private,
  84. const struct iio_chan_spec *chan,
  85. const char *buf, size_t len)
  86. {
  87. struct ad5446_state *st = iio_priv(indio_dev);
  88. unsigned int shift;
  89. unsigned int val;
  90. bool powerdown;
  91. int ret;
  92. ret = strtobool(buf, &powerdown);
  93. if (ret)
  94. return ret;
  95. mutex_lock(&indio_dev->mlock);
  96. st->pwr_down = powerdown;
  97. if (st->pwr_down) {
  98. shift = chan->scan_type.realbits + chan->scan_type.shift;
  99. val = st->pwr_down_mode << shift;
  100. } else {
  101. val = st->cached_val;
  102. }
  103. ret = st->chip_info->write(st, val);
  104. mutex_unlock(&indio_dev->mlock);
  105. return ret ? ret : len;
  106. }
  107. static const struct iio_chan_spec_ext_info ad5446_ext_info_powerdown[] = {
  108. {
  109. .name = "powerdown",
  110. .read = ad5446_read_dac_powerdown,
  111. .write = ad5446_write_dac_powerdown,
  112. },
  113. IIO_ENUM("powerdown_mode", false, &ad5446_powerdown_mode_enum),
  114. IIO_ENUM_AVAILABLE("powerdown_mode", &ad5446_powerdown_mode_enum),
  115. { },
  116. };
  117. #define _AD5446_CHANNEL(bits, storage, shift, ext) { \
  118. .type = IIO_VOLTAGE, \
  119. .indexed = 1, \
  120. .output = 1, \
  121. .channel = 0, \
  122. .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
  123. .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE), \
  124. .scan_type = IIO_ST('u', (bits), (storage), (shift)), \
  125. .ext_info = (ext), \
  126. }
  127. #define AD5446_CHANNEL(bits, storage, shift) \
  128. _AD5446_CHANNEL(bits, storage, shift, NULL)
  129. #define AD5446_CHANNEL_POWERDOWN(bits, storage, shift) \
  130. _AD5446_CHANNEL(bits, storage, shift, ad5446_ext_info_powerdown)
  131. static int ad5446_read_raw(struct iio_dev *indio_dev,
  132. struct iio_chan_spec const *chan,
  133. int *val,
  134. int *val2,
  135. long m)
  136. {
  137. struct ad5446_state *st = iio_priv(indio_dev);
  138. unsigned long scale_uv;
  139. switch (m) {
  140. case IIO_CHAN_INFO_RAW:
  141. *val = st->cached_val;
  142. return IIO_VAL_INT;
  143. case IIO_CHAN_INFO_SCALE:
  144. scale_uv = (st->vref_mv * 1000) >> chan->scan_type.realbits;
  145. *val = scale_uv / 1000;
  146. *val2 = (scale_uv % 1000) * 1000;
  147. return IIO_VAL_INT_PLUS_MICRO;
  148. }
  149. return -EINVAL;
  150. }
  151. static int ad5446_write_raw(struct iio_dev *indio_dev,
  152. struct iio_chan_spec const *chan,
  153. int val,
  154. int val2,
  155. long mask)
  156. {
  157. struct ad5446_state *st = iio_priv(indio_dev);
  158. int ret = 0;
  159. switch (mask) {
  160. case IIO_CHAN_INFO_RAW:
  161. if (val >= (1 << chan->scan_type.realbits) || val < 0)
  162. return -EINVAL;
  163. val <<= chan->scan_type.shift;
  164. mutex_lock(&indio_dev->mlock);
  165. st->cached_val = val;
  166. if (!st->pwr_down)
  167. ret = st->chip_info->write(st, val);
  168. mutex_unlock(&indio_dev->mlock);
  169. break;
  170. default:
  171. ret = -EINVAL;
  172. }
  173. return ret;
  174. }
  175. static const struct iio_info ad5446_info = {
  176. .read_raw = ad5446_read_raw,
  177. .write_raw = ad5446_write_raw,
  178. .driver_module = THIS_MODULE,
  179. };
  180. static int ad5446_probe(struct device *dev, const char *name,
  181. const struct ad5446_chip_info *chip_info)
  182. {
  183. struct ad5446_state *st;
  184. struct iio_dev *indio_dev;
  185. struct regulator *reg;
  186. int ret, voltage_uv = 0;
  187. reg = devm_regulator_get(dev, "vcc");
  188. if (!IS_ERR(reg)) {
  189. ret = regulator_enable(reg);
  190. if (ret)
  191. return ret;
  192. ret = regulator_get_voltage(reg);
  193. if (ret < 0)
  194. goto error_disable_reg;
  195. voltage_uv = ret;
  196. }
  197. indio_dev = devm_iio_device_alloc(dev, sizeof(*st));
  198. if (indio_dev == NULL) {
  199. ret = -ENOMEM;
  200. goto error_disable_reg;
  201. }
  202. st = iio_priv(indio_dev);
  203. st->chip_info = chip_info;
  204. dev_set_drvdata(dev, indio_dev);
  205. st->reg = reg;
  206. st->dev = dev;
  207. /* Establish that the iio_dev is a child of the device */
  208. indio_dev->dev.parent = dev;
  209. indio_dev->name = name;
  210. indio_dev->info = &ad5446_info;
  211. indio_dev->modes = INDIO_DIRECT_MODE;
  212. indio_dev->channels = &st->chip_info->channel;
  213. indio_dev->num_channels = 1;
  214. st->pwr_down_mode = MODE_PWRDWN_1k;
  215. if (st->chip_info->int_vref_mv)
  216. st->vref_mv = st->chip_info->int_vref_mv;
  217. else if (voltage_uv)
  218. st->vref_mv = voltage_uv / 1000;
  219. else
  220. dev_warn(dev, "reference voltage unspecified\n");
  221. ret = iio_device_register(indio_dev);
  222. if (ret)
  223. goto error_disable_reg;
  224. return 0;
  225. error_disable_reg:
  226. if (!IS_ERR(reg))
  227. regulator_disable(reg);
  228. return ret;
  229. }
  230. static int ad5446_remove(struct device *dev)
  231. {
  232. struct iio_dev *indio_dev = dev_get_drvdata(dev);
  233. struct ad5446_state *st = iio_priv(indio_dev);
  234. iio_device_unregister(indio_dev);
  235. if (!IS_ERR(st->reg))
  236. regulator_disable(st->reg);
  237. return 0;
  238. }
  239. #if IS_ENABLED(CONFIG_SPI_MASTER)
  240. static int ad5446_write(struct ad5446_state *st, unsigned val)
  241. {
  242. struct spi_device *spi = to_spi_device(st->dev);
  243. __be16 data = cpu_to_be16(val);
  244. return spi_write(spi, &data, sizeof(data));
  245. }
  246. static int ad5660_write(struct ad5446_state *st, unsigned val)
  247. {
  248. struct spi_device *spi = to_spi_device(st->dev);
  249. uint8_t data[3];
  250. data[0] = (val >> 16) & 0xFF;
  251. data[1] = (val >> 8) & 0xFF;
  252. data[2] = val & 0xFF;
  253. return spi_write(spi, data, sizeof(data));
  254. }
  255. /**
  256. * ad5446_supported_spi_device_ids:
  257. * The AD5620/40/60 parts are available in different fixed internal reference
  258. * voltage options. The actual part numbers may look differently
  259. * (and a bit cryptic), however this style is used to make clear which
  260. * parts are supported here.
  261. */
  262. enum ad5446_supported_spi_device_ids {
  263. ID_AD5300,
  264. ID_AD5310,
  265. ID_AD5320,
  266. ID_AD5444,
  267. ID_AD5446,
  268. ID_AD5450,
  269. ID_AD5451,
  270. ID_AD5541A,
  271. ID_AD5512A,
  272. ID_AD5553,
  273. ID_AD5601,
  274. ID_AD5611,
  275. ID_AD5621,
  276. ID_AD5620_2500,
  277. ID_AD5620_1250,
  278. ID_AD5640_2500,
  279. ID_AD5640_1250,
  280. ID_AD5660_2500,
  281. ID_AD5660_1250,
  282. ID_AD5662,
  283. };
  284. static const struct ad5446_chip_info ad5446_spi_chip_info[] = {
  285. [ID_AD5300] = {
  286. .channel = AD5446_CHANNEL_POWERDOWN(8, 16, 4),
  287. .write = ad5446_write,
  288. },
  289. [ID_AD5310] = {
  290. .channel = AD5446_CHANNEL_POWERDOWN(10, 16, 2),
  291. .write = ad5446_write,
  292. },
  293. [ID_AD5320] = {
  294. .channel = AD5446_CHANNEL_POWERDOWN(12, 16, 0),
  295. .write = ad5446_write,
  296. },
  297. [ID_AD5444] = {
  298. .channel = AD5446_CHANNEL(12, 16, 2),
  299. .write = ad5446_write,
  300. },
  301. [ID_AD5446] = {
  302. .channel = AD5446_CHANNEL(14, 16, 0),
  303. .write = ad5446_write,
  304. },
  305. [ID_AD5450] = {
  306. .channel = AD5446_CHANNEL(8, 16, 6),
  307. .write = ad5446_write,
  308. },
  309. [ID_AD5451] = {
  310. .channel = AD5446_CHANNEL(10, 16, 4),
  311. .write = ad5446_write,
  312. },
  313. [ID_AD5541A] = {
  314. .channel = AD5446_CHANNEL(16, 16, 0),
  315. .write = ad5446_write,
  316. },
  317. [ID_AD5512A] = {
  318. .channel = AD5446_CHANNEL(12, 16, 4),
  319. .write = ad5446_write,
  320. },
  321. [ID_AD5553] = {
  322. .channel = AD5446_CHANNEL(14, 16, 0),
  323. .write = ad5446_write,
  324. },
  325. [ID_AD5601] = {
  326. .channel = AD5446_CHANNEL_POWERDOWN(8, 16, 6),
  327. .write = ad5446_write,
  328. },
  329. [ID_AD5611] = {
  330. .channel = AD5446_CHANNEL_POWERDOWN(10, 16, 4),
  331. .write = ad5446_write,
  332. },
  333. [ID_AD5621] = {
  334. .channel = AD5446_CHANNEL_POWERDOWN(12, 16, 2),
  335. .write = ad5446_write,
  336. },
  337. [ID_AD5620_2500] = {
  338. .channel = AD5446_CHANNEL_POWERDOWN(12, 16, 2),
  339. .int_vref_mv = 2500,
  340. .write = ad5446_write,
  341. },
  342. [ID_AD5620_1250] = {
  343. .channel = AD5446_CHANNEL_POWERDOWN(12, 16, 2),
  344. .int_vref_mv = 1250,
  345. .write = ad5446_write,
  346. },
  347. [ID_AD5640_2500] = {
  348. .channel = AD5446_CHANNEL_POWERDOWN(14, 16, 0),
  349. .int_vref_mv = 2500,
  350. .write = ad5446_write,
  351. },
  352. [ID_AD5640_1250] = {
  353. .channel = AD5446_CHANNEL_POWERDOWN(14, 16, 0),
  354. .int_vref_mv = 1250,
  355. .write = ad5446_write,
  356. },
  357. [ID_AD5660_2500] = {
  358. .channel = AD5446_CHANNEL_POWERDOWN(16, 16, 0),
  359. .int_vref_mv = 2500,
  360. .write = ad5660_write,
  361. },
  362. [ID_AD5660_1250] = {
  363. .channel = AD5446_CHANNEL_POWERDOWN(16, 16, 0),
  364. .int_vref_mv = 1250,
  365. .write = ad5660_write,
  366. },
  367. [ID_AD5662] = {
  368. .channel = AD5446_CHANNEL_POWERDOWN(16, 16, 0),
  369. .write = ad5660_write,
  370. },
  371. };
  372. static const struct spi_device_id ad5446_spi_ids[] = {
  373. {"ad5300", ID_AD5300},
  374. {"ad5310", ID_AD5310},
  375. {"ad5320", ID_AD5320},
  376. {"ad5444", ID_AD5444},
  377. {"ad5446", ID_AD5446},
  378. {"ad5450", ID_AD5450},
  379. {"ad5451", ID_AD5451},
  380. {"ad5452", ID_AD5444}, /* ad5452 is compatible to the ad5444 */
  381. {"ad5453", ID_AD5446}, /* ad5453 is compatible to the ad5446 */
  382. {"ad5512a", ID_AD5512A},
  383. {"ad5541a", ID_AD5541A},
  384. {"ad5542a", ID_AD5541A}, /* ad5541a and ad5542a are compatible */
  385. {"ad5543", ID_AD5541A}, /* ad5541a and ad5543 are compatible */
  386. {"ad5553", ID_AD5553},
  387. {"ad5601", ID_AD5601},
  388. {"ad5611", ID_AD5611},
  389. {"ad5621", ID_AD5621},
  390. {"ad5620-2500", ID_AD5620_2500}, /* AD5620/40/60: */
  391. {"ad5620-1250", ID_AD5620_1250}, /* part numbers may look differently */
  392. {"ad5640-2500", ID_AD5640_2500},
  393. {"ad5640-1250", ID_AD5640_1250},
  394. {"ad5660-2500", ID_AD5660_2500},
  395. {"ad5660-1250", ID_AD5660_1250},
  396. {"ad5662", ID_AD5662},
  397. {}
  398. };
  399. MODULE_DEVICE_TABLE(spi, ad5446_spi_ids);
  400. static int ad5446_spi_probe(struct spi_device *spi)
  401. {
  402. const struct spi_device_id *id = spi_get_device_id(spi);
  403. return ad5446_probe(&spi->dev, id->name,
  404. &ad5446_spi_chip_info[id->driver_data]);
  405. }
  406. static int ad5446_spi_remove(struct spi_device *spi)
  407. {
  408. return ad5446_remove(&spi->dev);
  409. }
  410. static struct spi_driver ad5446_spi_driver = {
  411. .driver = {
  412. .name = "ad5446",
  413. .owner = THIS_MODULE,
  414. },
  415. .probe = ad5446_spi_probe,
  416. .remove = ad5446_spi_remove,
  417. .id_table = ad5446_spi_ids,
  418. };
  419. static int __init ad5446_spi_register_driver(void)
  420. {
  421. return spi_register_driver(&ad5446_spi_driver);
  422. }
  423. static void ad5446_spi_unregister_driver(void)
  424. {
  425. spi_unregister_driver(&ad5446_spi_driver);
  426. }
  427. #else
  428. static inline int ad5446_spi_register_driver(void) { return 0; }
  429. static inline void ad5446_spi_unregister_driver(void) { }
  430. #endif
  431. #if IS_ENABLED(CONFIG_I2C)
  432. static int ad5622_write(struct ad5446_state *st, unsigned val)
  433. {
  434. struct i2c_client *client = to_i2c_client(st->dev);
  435. __be16 data = cpu_to_be16(val);
  436. return i2c_master_send(client, (char *)&data, sizeof(data));
  437. }
  438. /**
  439. * ad5446_supported_i2c_device_ids:
  440. * The AD5620/40/60 parts are available in different fixed internal reference
  441. * voltage options. The actual part numbers may look differently
  442. * (and a bit cryptic), however this style is used to make clear which
  443. * parts are supported here.
  444. */
  445. enum ad5446_supported_i2c_device_ids {
  446. ID_AD5602,
  447. ID_AD5612,
  448. ID_AD5622,
  449. };
  450. static const struct ad5446_chip_info ad5446_i2c_chip_info[] = {
  451. [ID_AD5602] = {
  452. .channel = AD5446_CHANNEL_POWERDOWN(8, 16, 4),
  453. .write = ad5622_write,
  454. },
  455. [ID_AD5612] = {
  456. .channel = AD5446_CHANNEL_POWERDOWN(10, 16, 2),
  457. .write = ad5622_write,
  458. },
  459. [ID_AD5622] = {
  460. .channel = AD5446_CHANNEL_POWERDOWN(12, 16, 0),
  461. .write = ad5622_write,
  462. },
  463. };
  464. static int ad5446_i2c_probe(struct i2c_client *i2c,
  465. const struct i2c_device_id *id)
  466. {
  467. return ad5446_probe(&i2c->dev, id->name,
  468. &ad5446_i2c_chip_info[id->driver_data]);
  469. }
  470. static int ad5446_i2c_remove(struct i2c_client *i2c)
  471. {
  472. return ad5446_remove(&i2c->dev);
  473. }
  474. static const struct i2c_device_id ad5446_i2c_ids[] = {
  475. {"ad5301", ID_AD5602},
  476. {"ad5311", ID_AD5612},
  477. {"ad5321", ID_AD5622},
  478. {"ad5602", ID_AD5602},
  479. {"ad5612", ID_AD5612},
  480. {"ad5622", ID_AD5622},
  481. {}
  482. };
  483. MODULE_DEVICE_TABLE(i2c, ad5446_i2c_ids);
  484. static struct i2c_driver ad5446_i2c_driver = {
  485. .driver = {
  486. .name = "ad5446",
  487. .owner = THIS_MODULE,
  488. },
  489. .probe = ad5446_i2c_probe,
  490. .remove = ad5446_i2c_remove,
  491. .id_table = ad5446_i2c_ids,
  492. };
  493. static int __init ad5446_i2c_register_driver(void)
  494. {
  495. return i2c_add_driver(&ad5446_i2c_driver);
  496. }
  497. static void __exit ad5446_i2c_unregister_driver(void)
  498. {
  499. i2c_del_driver(&ad5446_i2c_driver);
  500. }
  501. #else
  502. static inline int ad5446_i2c_register_driver(void) { return 0; }
  503. static inline void ad5446_i2c_unregister_driver(void) { }
  504. #endif
  505. static int __init ad5446_init(void)
  506. {
  507. int ret;
  508. ret = ad5446_spi_register_driver();
  509. if (ret)
  510. return ret;
  511. ret = ad5446_i2c_register_driver();
  512. if (ret) {
  513. ad5446_spi_unregister_driver();
  514. return ret;
  515. }
  516. return 0;
  517. }
  518. module_init(ad5446_init);
  519. static void __exit ad5446_exit(void)
  520. {
  521. ad5446_i2c_unregister_driver();
  522. ad5446_spi_unregister_driver();
  523. }
  524. module_exit(ad5446_exit);
  525. MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
  526. MODULE_DESCRIPTION("Analog Devices AD5444/AD5446 DAC");
  527. MODULE_LICENSE("GPL v2");