ad7291.c 14 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * AD7291 8-Channel, I2C, 12-Bit SAR ADC with Temperature Sensor
  4. *
  5. * Copyright 2010-2011 Analog Devices Inc.
  6. */
  7. #include <linux/device.h>
  8. #include <linux/err.h>
  9. #include <linux/i2c.h>
  10. #include <linux/interrupt.h>
  11. #include <linux/kernel.h>
  12. #include <linux/module.h>
  13. #include <linux/mutex.h>
  14. #include <linux/regulator/consumer.h>
  15. #include <linux/slab.h>
  16. #include <linux/sysfs.h>
  17. #include <linux/iio/iio.h>
  18. #include <linux/iio/sysfs.h>
  19. #include <linux/iio/events.h>
  20. /*
  21. * Simplified handling
  22. *
  23. * If no events enabled - single polled channel read
  24. * If event enabled direct reads disable unless channel
  25. * is in the read mask.
  26. *
  27. * The noise-delayed bit as per datasheet suggestion is always enabled.
  28. */
  29. /*
  30. * AD7291 registers definition
  31. */
  32. #define AD7291_COMMAND 0x00
  33. #define AD7291_VOLTAGE 0x01
  34. #define AD7291_T_SENSE 0x02
  35. #define AD7291_T_AVERAGE 0x03
  36. #define AD7291_DATA_HIGH(x) ((x) * 3 + 0x4)
  37. #define AD7291_DATA_LOW(x) ((x) * 3 + 0x5)
  38. #define AD7291_HYST(x) ((x) * 3 + 0x6)
  39. #define AD7291_VOLTAGE_ALERT_STATUS 0x1F
  40. #define AD7291_T_ALERT_STATUS 0x20
  41. #define AD7291_BITS 12
  42. #define AD7291_VOLTAGE_LIMIT_COUNT 8
  43. /*
  44. * AD7291 command
  45. */
  46. #define AD7291_AUTOCYCLE BIT(0)
  47. #define AD7291_RESET BIT(1)
  48. #define AD7291_ALERT_CLEAR BIT(2)
  49. #define AD7291_ALERT_POLARITY BIT(3)
  50. #define AD7291_EXT_REF BIT(4)
  51. #define AD7291_NOISE_DELAY BIT(5)
  52. #define AD7291_T_SENSE_MASK BIT(7)
  53. #define AD7291_VOLTAGE_MASK GENMASK(15, 8)
  54. #define AD7291_VOLTAGE_OFFSET 8
  55. /*
  56. * AD7291 value masks
  57. */
  58. #define AD7291_VALUE_MASK GENMASK(11, 0)
  59. /*
  60. * AD7291 alert register bits
  61. */
  62. #define AD7291_T_LOW BIT(0)
  63. #define AD7291_T_HIGH BIT(1)
  64. #define AD7291_T_AVG_LOW BIT(2)
  65. #define AD7291_T_AVG_HIGH BIT(3)
  66. #define AD7291_V_LOW(x) BIT((x) * 2)
  67. #define AD7291_V_HIGH(x) BIT((x) * 2 + 1)
  68. struct ad7291_chip_info {
  69. struct i2c_client *client;
  70. struct regulator *reg;
  71. u16 command;
  72. u16 c_mask; /* Active voltage channels for events */
  73. struct mutex state_lock;
  74. };
  75. static int ad7291_i2c_read(struct ad7291_chip_info *chip, u8 reg, u16 *data)
  76. {
  77. struct i2c_client *client = chip->client;
  78. int ret = 0;
  79. ret = i2c_smbus_read_word_swapped(client, reg);
  80. if (ret < 0) {
  81. dev_err(&client->dev, "I2C read error\n");
  82. return ret;
  83. }
  84. *data = ret;
  85. return 0;
  86. }
  87. static int ad7291_i2c_write(struct ad7291_chip_info *chip, u8 reg, u16 data)
  88. {
  89. return i2c_smbus_write_word_swapped(chip->client, reg, data);
  90. }
  91. static irqreturn_t ad7291_event_handler(int irq, void *private)
  92. {
  93. struct iio_dev *indio_dev = private;
  94. struct ad7291_chip_info *chip = iio_priv(private);
  95. u16 t_status, v_status;
  96. u16 command;
  97. int i;
  98. s64 timestamp = iio_get_time_ns(indio_dev);
  99. if (ad7291_i2c_read(chip, AD7291_T_ALERT_STATUS, &t_status))
  100. return IRQ_HANDLED;
  101. if (ad7291_i2c_read(chip, AD7291_VOLTAGE_ALERT_STATUS, &v_status))
  102. return IRQ_HANDLED;
  103. if (!(t_status || v_status))
  104. return IRQ_HANDLED;
  105. command = chip->command | AD7291_ALERT_CLEAR;
  106. ad7291_i2c_write(chip, AD7291_COMMAND, command);
  107. command = chip->command & ~AD7291_ALERT_CLEAR;
  108. ad7291_i2c_write(chip, AD7291_COMMAND, command);
  109. /* For now treat t_sense and t_sense_average the same */
  110. if ((t_status & AD7291_T_LOW) || (t_status & AD7291_T_AVG_LOW))
  111. iio_push_event(indio_dev,
  112. IIO_UNMOD_EVENT_CODE(IIO_TEMP,
  113. 0,
  114. IIO_EV_TYPE_THRESH,
  115. IIO_EV_DIR_FALLING),
  116. timestamp);
  117. if ((t_status & AD7291_T_HIGH) || (t_status & AD7291_T_AVG_HIGH))
  118. iio_push_event(indio_dev,
  119. IIO_UNMOD_EVENT_CODE(IIO_TEMP,
  120. 0,
  121. IIO_EV_TYPE_THRESH,
  122. IIO_EV_DIR_RISING),
  123. timestamp);
  124. for (i = 0; i < AD7291_VOLTAGE_LIMIT_COUNT; i++) {
  125. if (v_status & AD7291_V_LOW(i))
  126. iio_push_event(indio_dev,
  127. IIO_UNMOD_EVENT_CODE(IIO_VOLTAGE,
  128. i,
  129. IIO_EV_TYPE_THRESH,
  130. IIO_EV_DIR_FALLING),
  131. timestamp);
  132. if (v_status & AD7291_V_HIGH(i))
  133. iio_push_event(indio_dev,
  134. IIO_UNMOD_EVENT_CODE(IIO_VOLTAGE,
  135. i,
  136. IIO_EV_TYPE_THRESH,
  137. IIO_EV_DIR_RISING),
  138. timestamp);
  139. }
  140. return IRQ_HANDLED;
  141. }
  142. static unsigned int ad7291_threshold_reg(const struct iio_chan_spec *chan,
  143. enum iio_event_direction dir,
  144. enum iio_event_info info)
  145. {
  146. unsigned int offset;
  147. switch (chan->type) {
  148. case IIO_VOLTAGE:
  149. offset = chan->channel;
  150. break;
  151. case IIO_TEMP:
  152. offset = AD7291_VOLTAGE_OFFSET;
  153. break;
  154. default:
  155. return 0;
  156. }
  157. switch (info) {
  158. case IIO_EV_INFO_VALUE:
  159. if (dir == IIO_EV_DIR_FALLING)
  160. return AD7291_DATA_HIGH(offset);
  161. else
  162. return AD7291_DATA_LOW(offset);
  163. case IIO_EV_INFO_HYSTERESIS:
  164. return AD7291_HYST(offset);
  165. default:
  166. break;
  167. }
  168. return 0;
  169. }
  170. static int ad7291_read_event_value(struct iio_dev *indio_dev,
  171. const struct iio_chan_spec *chan,
  172. enum iio_event_type type,
  173. enum iio_event_direction dir,
  174. enum iio_event_info info,
  175. int *val, int *val2)
  176. {
  177. struct ad7291_chip_info *chip = iio_priv(indio_dev);
  178. int ret;
  179. u16 uval;
  180. ret = ad7291_i2c_read(chip, ad7291_threshold_reg(chan, dir, info),
  181. &uval);
  182. if (ret < 0)
  183. return ret;
  184. if (info == IIO_EV_INFO_HYSTERESIS || chan->type == IIO_VOLTAGE)
  185. *val = uval & AD7291_VALUE_MASK;
  186. else
  187. *val = sign_extend32(uval, 11);
  188. return IIO_VAL_INT;
  189. }
  190. static int ad7291_write_event_value(struct iio_dev *indio_dev,
  191. const struct iio_chan_spec *chan,
  192. enum iio_event_type type,
  193. enum iio_event_direction dir,
  194. enum iio_event_info info,
  195. int val, int val2)
  196. {
  197. struct ad7291_chip_info *chip = iio_priv(indio_dev);
  198. if (info == IIO_EV_INFO_HYSTERESIS || chan->type == IIO_VOLTAGE) {
  199. if (val > AD7291_VALUE_MASK || val < 0)
  200. return -EINVAL;
  201. } else {
  202. if (val > 2047 || val < -2048)
  203. return -EINVAL;
  204. }
  205. return ad7291_i2c_write(chip, ad7291_threshold_reg(chan, dir, info),
  206. val);
  207. }
  208. static int ad7291_read_event_config(struct iio_dev *indio_dev,
  209. const struct iio_chan_spec *chan,
  210. enum iio_event_type type,
  211. enum iio_event_direction dir)
  212. {
  213. struct ad7291_chip_info *chip = iio_priv(indio_dev);
  214. /*
  215. * To be enabled the channel must simply be on. If any are enabled
  216. * we are in continuous sampling mode
  217. */
  218. switch (chan->type) {
  219. case IIO_VOLTAGE:
  220. return !!(chip->c_mask & BIT(15 - chan->channel));
  221. case IIO_TEMP:
  222. /* always on */
  223. return 1;
  224. default:
  225. return -EINVAL;
  226. }
  227. }
  228. static int ad7291_write_event_config(struct iio_dev *indio_dev,
  229. const struct iio_chan_spec *chan,
  230. enum iio_event_type type,
  231. enum iio_event_direction dir,
  232. int state)
  233. {
  234. int ret = 0;
  235. struct ad7291_chip_info *chip = iio_priv(indio_dev);
  236. unsigned int mask;
  237. u16 regval;
  238. mutex_lock(&chip->state_lock);
  239. regval = chip->command;
  240. /*
  241. * To be enabled the channel must simply be on. If any are enabled
  242. * use continuous sampling mode.
  243. * Possible to disable temp as well but that makes single read tricky.
  244. */
  245. mask = BIT(15 - chan->channel);
  246. switch (chan->type) {
  247. case IIO_VOLTAGE:
  248. if ((!state) && (chip->c_mask & mask))
  249. chip->c_mask &= ~mask;
  250. else if (state && (!(chip->c_mask & mask)))
  251. chip->c_mask |= mask;
  252. else
  253. break;
  254. regval &= ~AD7291_AUTOCYCLE;
  255. regval |= chip->c_mask;
  256. if (chip->c_mask) /* Enable autocycle? */
  257. regval |= AD7291_AUTOCYCLE;
  258. ret = ad7291_i2c_write(chip, AD7291_COMMAND, regval);
  259. if (ret < 0)
  260. goto error_ret;
  261. chip->command = regval;
  262. break;
  263. default:
  264. ret = -EINVAL;
  265. }
  266. error_ret:
  267. mutex_unlock(&chip->state_lock);
  268. return ret;
  269. }
  270. static int ad7291_read_raw(struct iio_dev *indio_dev,
  271. struct iio_chan_spec const *chan,
  272. int *val,
  273. int *val2,
  274. long mask)
  275. {
  276. int ret;
  277. struct ad7291_chip_info *chip = iio_priv(indio_dev);
  278. u16 regval;
  279. switch (mask) {
  280. case IIO_CHAN_INFO_RAW:
  281. switch (chan->type) {
  282. case IIO_VOLTAGE:
  283. mutex_lock(&chip->state_lock);
  284. /* If in autocycle mode drop through */
  285. if (chip->command & AD7291_AUTOCYCLE) {
  286. mutex_unlock(&chip->state_lock);
  287. return -EBUSY;
  288. }
  289. /* Enable this channel alone */
  290. regval = chip->command & (~AD7291_VOLTAGE_MASK);
  291. regval |= BIT(15 - chan->channel);
  292. ret = ad7291_i2c_write(chip, AD7291_COMMAND, regval);
  293. if (ret < 0) {
  294. mutex_unlock(&chip->state_lock);
  295. return ret;
  296. }
  297. /* Read voltage */
  298. ret = i2c_smbus_read_word_swapped(chip->client,
  299. AD7291_VOLTAGE);
  300. if (ret < 0) {
  301. mutex_unlock(&chip->state_lock);
  302. return ret;
  303. }
  304. *val = ret & AD7291_VALUE_MASK;
  305. mutex_unlock(&chip->state_lock);
  306. return IIO_VAL_INT;
  307. case IIO_TEMP:
  308. /* Assumes tsense bit of command register always set */
  309. ret = i2c_smbus_read_word_swapped(chip->client,
  310. AD7291_T_SENSE);
  311. if (ret < 0)
  312. return ret;
  313. *val = sign_extend32(ret, 11);
  314. return IIO_VAL_INT;
  315. default:
  316. return -EINVAL;
  317. }
  318. case IIO_CHAN_INFO_AVERAGE_RAW:
  319. ret = i2c_smbus_read_word_swapped(chip->client,
  320. AD7291_T_AVERAGE);
  321. if (ret < 0)
  322. return ret;
  323. *val = sign_extend32(ret, 11);
  324. return IIO_VAL_INT;
  325. case IIO_CHAN_INFO_SCALE:
  326. switch (chan->type) {
  327. case IIO_VOLTAGE:
  328. if (chip->reg) {
  329. int vref;
  330. vref = regulator_get_voltage(chip->reg);
  331. if (vref < 0)
  332. return vref;
  333. *val = vref / 1000;
  334. } else {
  335. *val = 2500;
  336. }
  337. *val2 = AD7291_BITS;
  338. return IIO_VAL_FRACTIONAL_LOG2;
  339. case IIO_TEMP:
  340. /*
  341. * One LSB of the ADC corresponds to 0.25 deg C.
  342. * The temperature reading is in 12-bit twos
  343. * complement format
  344. */
  345. *val = 250;
  346. return IIO_VAL_INT;
  347. default:
  348. return -EINVAL;
  349. }
  350. default:
  351. return -EINVAL;
  352. }
  353. }
  354. static const struct iio_event_spec ad7291_events[] = {
  355. {
  356. .type = IIO_EV_TYPE_THRESH,
  357. .dir = IIO_EV_DIR_RISING,
  358. .mask_separate = BIT(IIO_EV_INFO_VALUE) |
  359. BIT(IIO_EV_INFO_ENABLE),
  360. }, {
  361. .type = IIO_EV_TYPE_THRESH,
  362. .dir = IIO_EV_DIR_FALLING,
  363. .mask_separate = BIT(IIO_EV_INFO_VALUE) |
  364. BIT(IIO_EV_INFO_ENABLE),
  365. }, {
  366. .type = IIO_EV_TYPE_THRESH,
  367. .dir = IIO_EV_DIR_EITHER,
  368. .mask_separate = BIT(IIO_EV_INFO_HYSTERESIS),
  369. },
  370. };
  371. #define AD7291_VOLTAGE_CHAN(_chan) \
  372. { \
  373. .type = IIO_VOLTAGE, \
  374. .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
  375. .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE), \
  376. .indexed = 1, \
  377. .channel = _chan, \
  378. .event_spec = ad7291_events, \
  379. .num_event_specs = ARRAY_SIZE(ad7291_events), \
  380. }
  381. static const struct iio_chan_spec ad7291_channels[] = {
  382. AD7291_VOLTAGE_CHAN(0),
  383. AD7291_VOLTAGE_CHAN(1),
  384. AD7291_VOLTAGE_CHAN(2),
  385. AD7291_VOLTAGE_CHAN(3),
  386. AD7291_VOLTAGE_CHAN(4),
  387. AD7291_VOLTAGE_CHAN(5),
  388. AD7291_VOLTAGE_CHAN(6),
  389. AD7291_VOLTAGE_CHAN(7),
  390. {
  391. .type = IIO_TEMP,
  392. .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
  393. BIT(IIO_CHAN_INFO_AVERAGE_RAW) |
  394. BIT(IIO_CHAN_INFO_SCALE),
  395. .indexed = 1,
  396. .channel = 0,
  397. .event_spec = ad7291_events,
  398. .num_event_specs = ARRAY_SIZE(ad7291_events),
  399. }
  400. };
  401. static const struct iio_info ad7291_info = {
  402. .read_raw = &ad7291_read_raw,
  403. .read_event_config = &ad7291_read_event_config,
  404. .write_event_config = &ad7291_write_event_config,
  405. .read_event_value = &ad7291_read_event_value,
  406. .write_event_value = &ad7291_write_event_value,
  407. };
  408. static int ad7291_probe(struct i2c_client *client,
  409. const struct i2c_device_id *id)
  410. {
  411. struct ad7291_chip_info *chip;
  412. struct iio_dev *indio_dev;
  413. int ret;
  414. indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*chip));
  415. if (!indio_dev)
  416. return -ENOMEM;
  417. chip = iio_priv(indio_dev);
  418. mutex_init(&chip->state_lock);
  419. /* this is only used for device removal purposes */
  420. i2c_set_clientdata(client, indio_dev);
  421. chip->client = client;
  422. chip->command = AD7291_NOISE_DELAY |
  423. AD7291_T_SENSE_MASK | /* Tsense always enabled */
  424. AD7291_ALERT_POLARITY; /* set irq polarity low level */
  425. chip->reg = devm_regulator_get_optional(&client->dev, "vref");
  426. if (IS_ERR(chip->reg)) {
  427. if (PTR_ERR(chip->reg) != -ENODEV)
  428. return PTR_ERR(chip->reg);
  429. chip->reg = NULL;
  430. }
  431. if (chip->reg) {
  432. ret = regulator_enable(chip->reg);
  433. if (ret)
  434. return ret;
  435. chip->command |= AD7291_EXT_REF;
  436. }
  437. indio_dev->name = id->name;
  438. indio_dev->channels = ad7291_channels;
  439. indio_dev->num_channels = ARRAY_SIZE(ad7291_channels);
  440. indio_dev->info = &ad7291_info;
  441. indio_dev->modes = INDIO_DIRECT_MODE;
  442. ret = ad7291_i2c_write(chip, AD7291_COMMAND, AD7291_RESET);
  443. if (ret) {
  444. ret = -EIO;
  445. goto error_disable_reg;
  446. }
  447. ret = ad7291_i2c_write(chip, AD7291_COMMAND, chip->command);
  448. if (ret) {
  449. ret = -EIO;
  450. goto error_disable_reg;
  451. }
  452. if (client->irq > 0) {
  453. ret = request_threaded_irq(client->irq,
  454. NULL,
  455. &ad7291_event_handler,
  456. IRQF_TRIGGER_LOW | IRQF_ONESHOT,
  457. id->name,
  458. indio_dev);
  459. if (ret)
  460. goto error_disable_reg;
  461. }
  462. ret = iio_device_register(indio_dev);
  463. if (ret)
  464. goto error_unreg_irq;
  465. return 0;
  466. error_unreg_irq:
  467. if (client->irq)
  468. free_irq(client->irq, indio_dev);
  469. error_disable_reg:
  470. if (chip->reg)
  471. regulator_disable(chip->reg);
  472. return ret;
  473. }
  474. static int ad7291_remove(struct i2c_client *client)
  475. {
  476. struct iio_dev *indio_dev = i2c_get_clientdata(client);
  477. struct ad7291_chip_info *chip = iio_priv(indio_dev);
  478. iio_device_unregister(indio_dev);
  479. if (client->irq)
  480. free_irq(client->irq, indio_dev);
  481. if (chip->reg)
  482. regulator_disable(chip->reg);
  483. return 0;
  484. }
  485. static const struct i2c_device_id ad7291_id[] = {
  486. { "ad7291", 0 },
  487. {}
  488. };
  489. MODULE_DEVICE_TABLE(i2c, ad7291_id);
  490. static const struct of_device_id ad7291_of_match[] = {
  491. { .compatible = "adi,ad7291" },
  492. {}
  493. };
  494. MODULE_DEVICE_TABLE(of, ad7291_of_match);
  495. static struct i2c_driver ad7291_driver = {
  496. .driver = {
  497. .name = KBUILD_MODNAME,
  498. .of_match_table = ad7291_of_match,
  499. },
  500. .probe = ad7291_probe,
  501. .remove = ad7291_remove,
  502. .id_table = ad7291_id,
  503. };
  504. module_i2c_driver(ad7291_driver);
  505. MODULE_AUTHOR("Sonic Zhang <sonic.zhang@analog.com>");
  506. MODULE_DESCRIPTION("Analog Devices AD7291 ADC driver");
  507. MODULE_LICENSE("GPL v2");