da9150-gpadc.c 10 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * DA9150 GPADC Driver
  4. *
  5. * Copyright (c) 2014 Dialog Semiconductor
  6. *
  7. * Author: Adam Thomson <Adam.Thomson.Opensource@diasemi.com>
  8. */
  9. #include <linux/kernel.h>
  10. #include <linux/slab.h>
  11. #include <linux/module.h>
  12. #include <linux/platform_device.h>
  13. #include <linux/interrupt.h>
  14. #include <linux/mutex.h>
  15. #include <linux/completion.h>
  16. #include <linux/iio/iio.h>
  17. #include <linux/iio/machine.h>
  18. #include <linux/iio/driver.h>
  19. #include <linux/mfd/da9150/core.h>
  20. #include <linux/mfd/da9150/registers.h>
  21. /* Channels */
  22. enum da9150_gpadc_hw_channel {
  23. DA9150_GPADC_HW_CHAN_GPIOA_2V = 0,
  24. DA9150_GPADC_HW_CHAN_GPIOA_2V_,
  25. DA9150_GPADC_HW_CHAN_GPIOB_2V,
  26. DA9150_GPADC_HW_CHAN_GPIOB_2V_,
  27. DA9150_GPADC_HW_CHAN_GPIOC_2V,
  28. DA9150_GPADC_HW_CHAN_GPIOC_2V_,
  29. DA9150_GPADC_HW_CHAN_GPIOD_2V,
  30. DA9150_GPADC_HW_CHAN_GPIOD_2V_,
  31. DA9150_GPADC_HW_CHAN_IBUS_SENSE,
  32. DA9150_GPADC_HW_CHAN_IBUS_SENSE_,
  33. DA9150_GPADC_HW_CHAN_VBUS_DIV,
  34. DA9150_GPADC_HW_CHAN_VBUS_DIV_,
  35. DA9150_GPADC_HW_CHAN_ID,
  36. DA9150_GPADC_HW_CHAN_ID_,
  37. DA9150_GPADC_HW_CHAN_VSYS,
  38. DA9150_GPADC_HW_CHAN_VSYS_,
  39. DA9150_GPADC_HW_CHAN_GPIOA_6V,
  40. DA9150_GPADC_HW_CHAN_GPIOA_6V_,
  41. DA9150_GPADC_HW_CHAN_GPIOB_6V,
  42. DA9150_GPADC_HW_CHAN_GPIOB_6V_,
  43. DA9150_GPADC_HW_CHAN_GPIOC_6V,
  44. DA9150_GPADC_HW_CHAN_GPIOC_6V_,
  45. DA9150_GPADC_HW_CHAN_GPIOD_6V,
  46. DA9150_GPADC_HW_CHAN_GPIOD_6V_,
  47. DA9150_GPADC_HW_CHAN_VBAT,
  48. DA9150_GPADC_HW_CHAN_VBAT_,
  49. DA9150_GPADC_HW_CHAN_TBAT,
  50. DA9150_GPADC_HW_CHAN_TBAT_,
  51. DA9150_GPADC_HW_CHAN_TJUNC_CORE,
  52. DA9150_GPADC_HW_CHAN_TJUNC_CORE_,
  53. DA9150_GPADC_HW_CHAN_TJUNC_OVP,
  54. DA9150_GPADC_HW_CHAN_TJUNC_OVP_,
  55. };
  56. enum da9150_gpadc_channel {
  57. DA9150_GPADC_CHAN_GPIOA = 0,
  58. DA9150_GPADC_CHAN_GPIOB,
  59. DA9150_GPADC_CHAN_GPIOC,
  60. DA9150_GPADC_CHAN_GPIOD,
  61. DA9150_GPADC_CHAN_IBUS,
  62. DA9150_GPADC_CHAN_VBUS,
  63. DA9150_GPADC_CHAN_VSYS,
  64. DA9150_GPADC_CHAN_VBAT,
  65. DA9150_GPADC_CHAN_TBAT,
  66. DA9150_GPADC_CHAN_TJUNC_CORE,
  67. DA9150_GPADC_CHAN_TJUNC_OVP,
  68. };
  69. /* Private data */
  70. struct da9150_gpadc {
  71. struct da9150 *da9150;
  72. struct device *dev;
  73. struct mutex lock;
  74. struct completion complete;
  75. };
  76. static irqreturn_t da9150_gpadc_irq(int irq, void *data)
  77. {
  78. struct da9150_gpadc *gpadc = data;
  79. complete(&gpadc->complete);
  80. return IRQ_HANDLED;
  81. }
  82. static int da9150_gpadc_read_adc(struct da9150_gpadc *gpadc, int hw_chan)
  83. {
  84. u8 result_regs[2];
  85. int result;
  86. mutex_lock(&gpadc->lock);
  87. /* Set channel & enable measurement */
  88. da9150_reg_write(gpadc->da9150, DA9150_GPADC_MAN,
  89. (DA9150_GPADC_EN_MASK |
  90. hw_chan << DA9150_GPADC_MUX_SHIFT));
  91. /* Consume left-over completion from a previous timeout */
  92. try_wait_for_completion(&gpadc->complete);
  93. /* Check for actual completion */
  94. wait_for_completion_timeout(&gpadc->complete, msecs_to_jiffies(5));
  95. /* Read result and status from device */
  96. da9150_bulk_read(gpadc->da9150, DA9150_GPADC_RES_A, 2, result_regs);
  97. mutex_unlock(&gpadc->lock);
  98. /* Check to make sure device really has completed reading */
  99. if (result_regs[1] & DA9150_GPADC_RUN_MASK) {
  100. dev_err(gpadc->dev, "Timeout on channel %d of GPADC\n",
  101. hw_chan);
  102. return -ETIMEDOUT;
  103. }
  104. /* LSBs - 2 bits */
  105. result = (result_regs[1] & DA9150_GPADC_RES_L_MASK) >>
  106. DA9150_GPADC_RES_L_SHIFT;
  107. /* MSBs - 8 bits */
  108. result |= result_regs[0] << DA9150_GPADC_RES_L_BITS;
  109. return result;
  110. }
  111. static inline int da9150_gpadc_gpio_6v_voltage_now(int raw_val)
  112. {
  113. /* Convert to mV */
  114. return (6 * ((raw_val * 1000) + 500)) / 1024;
  115. }
  116. static inline int da9150_gpadc_ibus_current_avg(int raw_val)
  117. {
  118. /* Convert to mA */
  119. return (4 * ((raw_val * 1000) + 500)) / 2048;
  120. }
  121. static inline int da9150_gpadc_vbus_21v_voltage_now(int raw_val)
  122. {
  123. /* Convert to mV */
  124. return (21 * ((raw_val * 1000) + 500)) / 1024;
  125. }
  126. static inline int da9150_gpadc_vsys_6v_voltage_now(int raw_val)
  127. {
  128. /* Convert to mV */
  129. return (3 * ((raw_val * 1000) + 500)) / 512;
  130. }
  131. static int da9150_gpadc_read_processed(struct da9150_gpadc *gpadc, int channel,
  132. int hw_chan, int *val)
  133. {
  134. int raw_val;
  135. raw_val = da9150_gpadc_read_adc(gpadc, hw_chan);
  136. if (raw_val < 0)
  137. return raw_val;
  138. switch (channel) {
  139. case DA9150_GPADC_CHAN_GPIOA:
  140. case DA9150_GPADC_CHAN_GPIOB:
  141. case DA9150_GPADC_CHAN_GPIOC:
  142. case DA9150_GPADC_CHAN_GPIOD:
  143. *val = da9150_gpadc_gpio_6v_voltage_now(raw_val);
  144. break;
  145. case DA9150_GPADC_CHAN_IBUS:
  146. *val = da9150_gpadc_ibus_current_avg(raw_val);
  147. break;
  148. case DA9150_GPADC_CHAN_VBUS:
  149. *val = da9150_gpadc_vbus_21v_voltage_now(raw_val);
  150. break;
  151. case DA9150_GPADC_CHAN_VSYS:
  152. *val = da9150_gpadc_vsys_6v_voltage_now(raw_val);
  153. break;
  154. default:
  155. /* No processing for other channels so return raw value */
  156. *val = raw_val;
  157. break;
  158. }
  159. return IIO_VAL_INT;
  160. }
  161. static int da9150_gpadc_read_scale(int channel, int *val, int *val2)
  162. {
  163. switch (channel) {
  164. case DA9150_GPADC_CHAN_VBAT:
  165. *val = 2932;
  166. *val2 = 1000;
  167. return IIO_VAL_FRACTIONAL;
  168. case DA9150_GPADC_CHAN_TJUNC_CORE:
  169. case DA9150_GPADC_CHAN_TJUNC_OVP:
  170. *val = 1000000;
  171. *val2 = 4420;
  172. return IIO_VAL_FRACTIONAL;
  173. default:
  174. return -EINVAL;
  175. }
  176. }
  177. static int da9150_gpadc_read_offset(int channel, int *val)
  178. {
  179. switch (channel) {
  180. case DA9150_GPADC_CHAN_VBAT:
  181. *val = 1500000 / 2932;
  182. return IIO_VAL_INT;
  183. case DA9150_GPADC_CHAN_TJUNC_CORE:
  184. case DA9150_GPADC_CHAN_TJUNC_OVP:
  185. *val = -144;
  186. return IIO_VAL_INT;
  187. default:
  188. return -EINVAL;
  189. }
  190. }
  191. static int da9150_gpadc_read_raw(struct iio_dev *indio_dev,
  192. struct iio_chan_spec const *chan,
  193. int *val, int *val2, long mask)
  194. {
  195. struct da9150_gpadc *gpadc = iio_priv(indio_dev);
  196. if ((chan->channel < DA9150_GPADC_CHAN_GPIOA) ||
  197. (chan->channel > DA9150_GPADC_CHAN_TJUNC_OVP))
  198. return -EINVAL;
  199. switch (mask) {
  200. case IIO_CHAN_INFO_RAW:
  201. case IIO_CHAN_INFO_PROCESSED:
  202. return da9150_gpadc_read_processed(gpadc, chan->channel,
  203. chan->address, val);
  204. case IIO_CHAN_INFO_SCALE:
  205. return da9150_gpadc_read_scale(chan->channel, val, val2);
  206. case IIO_CHAN_INFO_OFFSET:
  207. return da9150_gpadc_read_offset(chan->channel, val);
  208. default:
  209. return -EINVAL;
  210. }
  211. }
  212. static const struct iio_info da9150_gpadc_info = {
  213. .read_raw = &da9150_gpadc_read_raw,
  214. };
  215. #define DA9150_GPADC_CHANNEL(_id, _hw_id, _type, chan_info, \
  216. _ext_name) { \
  217. .type = _type, \
  218. .indexed = 1, \
  219. .channel = DA9150_GPADC_CHAN_##_id, \
  220. .address = DA9150_GPADC_HW_CHAN_##_hw_id, \
  221. .info_mask_separate = chan_info, \
  222. .extend_name = _ext_name, \
  223. .datasheet_name = #_id, \
  224. }
  225. #define DA9150_GPADC_CHANNEL_RAW(_id, _hw_id, _type, _ext_name) \
  226. DA9150_GPADC_CHANNEL(_id, _hw_id, _type, \
  227. BIT(IIO_CHAN_INFO_RAW), _ext_name)
  228. #define DA9150_GPADC_CHANNEL_SCALED(_id, _hw_id, _type, _ext_name) \
  229. DA9150_GPADC_CHANNEL(_id, _hw_id, _type, \
  230. BIT(IIO_CHAN_INFO_RAW) | \
  231. BIT(IIO_CHAN_INFO_SCALE) | \
  232. BIT(IIO_CHAN_INFO_OFFSET), \
  233. _ext_name)
  234. #define DA9150_GPADC_CHANNEL_PROCESSED(_id, _hw_id, _type, _ext_name) \
  235. DA9150_GPADC_CHANNEL(_id, _hw_id, _type, \
  236. BIT(IIO_CHAN_INFO_PROCESSED), _ext_name)
  237. /* Supported channels */
  238. static const struct iio_chan_spec da9150_gpadc_channels[] = {
  239. DA9150_GPADC_CHANNEL_PROCESSED(GPIOA, GPIOA_6V, IIO_VOLTAGE, NULL),
  240. DA9150_GPADC_CHANNEL_PROCESSED(GPIOB, GPIOB_6V, IIO_VOLTAGE, NULL),
  241. DA9150_GPADC_CHANNEL_PROCESSED(GPIOC, GPIOC_6V, IIO_VOLTAGE, NULL),
  242. DA9150_GPADC_CHANNEL_PROCESSED(GPIOD, GPIOD_6V, IIO_VOLTAGE, NULL),
  243. DA9150_GPADC_CHANNEL_PROCESSED(IBUS, IBUS_SENSE, IIO_CURRENT, "ibus"),
  244. DA9150_GPADC_CHANNEL_PROCESSED(VBUS, VBUS_DIV_, IIO_VOLTAGE, "vbus"),
  245. DA9150_GPADC_CHANNEL_PROCESSED(VSYS, VSYS, IIO_VOLTAGE, "vsys"),
  246. DA9150_GPADC_CHANNEL_SCALED(VBAT, VBAT, IIO_VOLTAGE, "vbat"),
  247. DA9150_GPADC_CHANNEL_RAW(TBAT, TBAT, IIO_VOLTAGE, "tbat"),
  248. DA9150_GPADC_CHANNEL_SCALED(TJUNC_CORE, TJUNC_CORE, IIO_TEMP,
  249. "tjunc_core"),
  250. DA9150_GPADC_CHANNEL_SCALED(TJUNC_OVP, TJUNC_OVP, IIO_TEMP,
  251. "tjunc_ovp"),
  252. };
  253. /* Default maps used by da9150-charger */
  254. static struct iio_map da9150_gpadc_default_maps[] = {
  255. {
  256. .consumer_dev_name = "da9150-charger",
  257. .consumer_channel = "CHAN_IBUS",
  258. .adc_channel_label = "IBUS",
  259. },
  260. {
  261. .consumer_dev_name = "da9150-charger",
  262. .consumer_channel = "CHAN_VBUS",
  263. .adc_channel_label = "VBUS",
  264. },
  265. {
  266. .consumer_dev_name = "da9150-charger",
  267. .consumer_channel = "CHAN_TJUNC",
  268. .adc_channel_label = "TJUNC_CORE",
  269. },
  270. {
  271. .consumer_dev_name = "da9150-charger",
  272. .consumer_channel = "CHAN_VBAT",
  273. .adc_channel_label = "VBAT",
  274. },
  275. {},
  276. };
  277. static int da9150_gpadc_probe(struct platform_device *pdev)
  278. {
  279. struct device *dev = &pdev->dev;
  280. struct da9150 *da9150 = dev_get_drvdata(dev->parent);
  281. struct da9150_gpadc *gpadc;
  282. struct iio_dev *indio_dev;
  283. int irq, ret;
  284. indio_dev = devm_iio_device_alloc(dev, sizeof(*gpadc));
  285. if (!indio_dev) {
  286. dev_err(&pdev->dev, "Failed to allocate IIO device\n");
  287. return -ENOMEM;
  288. }
  289. gpadc = iio_priv(indio_dev);
  290. platform_set_drvdata(pdev, indio_dev);
  291. gpadc->da9150 = da9150;
  292. gpadc->dev = dev;
  293. mutex_init(&gpadc->lock);
  294. init_completion(&gpadc->complete);
  295. irq = platform_get_irq_byname(pdev, "GPADC");
  296. if (irq < 0)
  297. return irq;
  298. ret = devm_request_threaded_irq(dev, irq, NULL, da9150_gpadc_irq,
  299. IRQF_ONESHOT, "GPADC", gpadc);
  300. if (ret) {
  301. dev_err(dev, "Failed to request IRQ %d: %d\n", irq, ret);
  302. return ret;
  303. }
  304. ret = iio_map_array_register(indio_dev, da9150_gpadc_default_maps);
  305. if (ret) {
  306. dev_err(dev, "Failed to register IIO maps: %d\n", ret);
  307. return ret;
  308. }
  309. indio_dev->name = dev_name(dev);
  310. indio_dev->info = &da9150_gpadc_info;
  311. indio_dev->modes = INDIO_DIRECT_MODE;
  312. indio_dev->channels = da9150_gpadc_channels;
  313. indio_dev->num_channels = ARRAY_SIZE(da9150_gpadc_channels);
  314. ret = iio_device_register(indio_dev);
  315. if (ret) {
  316. dev_err(dev, "Failed to register IIO device: %d\n", ret);
  317. goto iio_map_unreg;
  318. }
  319. return 0;
  320. iio_map_unreg:
  321. iio_map_array_unregister(indio_dev);
  322. return ret;
  323. }
  324. static int da9150_gpadc_remove(struct platform_device *pdev)
  325. {
  326. struct iio_dev *indio_dev = platform_get_drvdata(pdev);
  327. iio_device_unregister(indio_dev);
  328. iio_map_array_unregister(indio_dev);
  329. return 0;
  330. }
  331. static struct platform_driver da9150_gpadc_driver = {
  332. .driver = {
  333. .name = "da9150-gpadc",
  334. },
  335. .probe = da9150_gpadc_probe,
  336. .remove = da9150_gpadc_remove,
  337. };
  338. module_platform_driver(da9150_gpadc_driver);
  339. MODULE_DESCRIPTION("GPADC Driver for DA9150");
  340. MODULE_AUTHOR("Adam Thomson <Adam.Thomson.Opensource@diasemi.com>");
  341. MODULE_LICENSE("GPL");