adc-uclass.c 9.4 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * Copyright (C) 2015 Samsung Electronics
  4. * Przemyslaw Marczak <p.marczak@samsung.com>
  5. */
  6. #include <common.h>
  7. #include <errno.h>
  8. #include <div64.h>
  9. #include <dm.h>
  10. #include <dm/lists.h>
  11. #include <dm/device-internal.h>
  12. #include <dm/uclass-internal.h>
  13. #include <adc.h>
  14. #include <linux/delay.h>
  15. #include <power/regulator.h>
  16. #define ADC_UCLASS_PLATDATA_SIZE sizeof(struct adc_uclass_platdata)
  17. #define CHECK_NUMBER true
  18. #define CHECK_MASK (!CHECK_NUMBER)
  19. /* TODO: add support for timer uclass (for early calls) */
  20. #ifdef CONFIG_SANDBOX_ARCH
  21. #define sdelay(x) udelay(x)
  22. #else
  23. extern void sdelay(unsigned long loops);
  24. #endif
  25. static int check_channel(struct udevice *dev, int value, bool number_or_mask,
  26. const char *caller_function)
  27. {
  28. struct adc_uclass_platdata *uc_pdata = dev_get_uclass_platdata(dev);
  29. unsigned mask = number_or_mask ? (1 << value) : value;
  30. /* For the real ADC hardware, some ADC channels can be inactive.
  31. * For example if device has 4 analog channels, and only channels
  32. * 1-st and 3-rd are valid, then channel mask is: 0b1010, so request
  33. * with mask 0b1110 should return an error.
  34. */
  35. if ((uc_pdata->channel_mask >= mask) && (uc_pdata->channel_mask & mask))
  36. return 0;
  37. printf("Error in %s/%s().\nWrong channel selection for device: %s\n",
  38. __FILE__, caller_function, dev->name);
  39. return -EINVAL;
  40. }
  41. static int adc_supply_enable(struct udevice *dev)
  42. {
  43. struct adc_uclass_platdata *uc_pdata = dev_get_uclass_platdata(dev);
  44. const char *supply_type;
  45. int ret = 0;
  46. if (uc_pdata->vdd_supply) {
  47. supply_type = "vdd";
  48. ret = regulator_set_enable(uc_pdata->vdd_supply, true);
  49. }
  50. if (!ret && uc_pdata->vss_supply) {
  51. supply_type = "vss";
  52. ret = regulator_set_enable(uc_pdata->vss_supply, true);
  53. }
  54. if (ret)
  55. pr_err("%s: can't enable %s-supply!", dev->name, supply_type);
  56. return ret;
  57. }
  58. int adc_data_mask(struct udevice *dev, unsigned int *data_mask)
  59. {
  60. struct adc_uclass_platdata *uc_pdata = dev_get_uclass_platdata(dev);
  61. if (!uc_pdata)
  62. return -ENOSYS;
  63. *data_mask = uc_pdata->data_mask;
  64. return 0;
  65. }
  66. int adc_channel_mask(struct udevice *dev, unsigned int *channel_mask)
  67. {
  68. struct adc_uclass_platdata *uc_pdata = dev_get_uclass_platdata(dev);
  69. if (!uc_pdata)
  70. return -ENOSYS;
  71. *channel_mask = uc_pdata->channel_mask;
  72. return 0;
  73. }
  74. int adc_stop(struct udevice *dev)
  75. {
  76. const struct adc_ops *ops = dev_get_driver_ops(dev);
  77. if (!ops->stop)
  78. return -ENOSYS;
  79. return ops->stop(dev);
  80. }
  81. int adc_start_channel(struct udevice *dev, int channel)
  82. {
  83. const struct adc_ops *ops = dev_get_driver_ops(dev);
  84. int ret;
  85. if (!ops->start_channel)
  86. return -ENOSYS;
  87. ret = check_channel(dev, channel, CHECK_NUMBER, __func__);
  88. if (ret)
  89. return ret;
  90. ret = adc_supply_enable(dev);
  91. if (ret)
  92. return ret;
  93. return ops->start_channel(dev, channel);
  94. }
  95. int adc_start_channels(struct udevice *dev, unsigned int channel_mask)
  96. {
  97. const struct adc_ops *ops = dev_get_driver_ops(dev);
  98. int ret;
  99. if (!ops->start_channels)
  100. return -ENOSYS;
  101. ret = check_channel(dev, channel_mask, CHECK_MASK, __func__);
  102. if (ret)
  103. return ret;
  104. ret = adc_supply_enable(dev);
  105. if (ret)
  106. return ret;
  107. return ops->start_channels(dev, channel_mask);
  108. }
  109. int adc_channel_data(struct udevice *dev, int channel, unsigned int *data)
  110. {
  111. struct adc_uclass_platdata *uc_pdata = dev_get_uclass_platdata(dev);
  112. const struct adc_ops *ops = dev_get_driver_ops(dev);
  113. unsigned int timeout_us = uc_pdata->data_timeout_us;
  114. int ret;
  115. if (!ops->channel_data)
  116. return -ENOSYS;
  117. ret = check_channel(dev, channel, CHECK_NUMBER, __func__);
  118. if (ret)
  119. return ret;
  120. do {
  121. ret = ops->channel_data(dev, channel, data);
  122. if (!ret || ret != -EBUSY)
  123. break;
  124. /* TODO: use timer uclass (for early calls). */
  125. sdelay(5);
  126. } while (timeout_us--);
  127. return ret;
  128. }
  129. int adc_channels_data(struct udevice *dev, unsigned int channel_mask,
  130. struct adc_channel *channels)
  131. {
  132. struct adc_uclass_platdata *uc_pdata = dev_get_uclass_platdata(dev);
  133. unsigned int timeout_us = uc_pdata->multidata_timeout_us;
  134. const struct adc_ops *ops = dev_get_driver_ops(dev);
  135. int ret;
  136. if (!ops->channels_data)
  137. return -ENOSYS;
  138. ret = check_channel(dev, channel_mask, CHECK_MASK, __func__);
  139. if (ret)
  140. return ret;
  141. do {
  142. ret = ops->channels_data(dev, channel_mask, channels);
  143. if (!ret || ret != -EBUSY)
  144. break;
  145. /* TODO: use timer uclass (for early calls). */
  146. sdelay(5);
  147. } while (timeout_us--);
  148. return ret;
  149. }
  150. int adc_channel_single_shot(const char *name, int channel, unsigned int *data)
  151. {
  152. struct udevice *dev;
  153. int ret;
  154. ret = uclass_get_device_by_name(UCLASS_ADC, name, &dev);
  155. if (ret)
  156. return ret;
  157. ret = adc_start_channel(dev, channel);
  158. if (ret)
  159. return ret;
  160. ret = adc_channel_data(dev, channel, data);
  161. if (ret)
  162. return ret;
  163. return 0;
  164. }
  165. static int _adc_channels_single_shot(struct udevice *dev,
  166. unsigned int channel_mask,
  167. struct adc_channel *channels)
  168. {
  169. unsigned int data;
  170. int channel, ret;
  171. for (channel = 0; channel <= ADC_MAX_CHANNEL; channel++) {
  172. /* Check channel bit. */
  173. if (!((channel_mask >> channel) & 0x1))
  174. continue;
  175. ret = adc_start_channel(dev, channel);
  176. if (ret)
  177. return ret;
  178. ret = adc_channel_data(dev, channel, &data);
  179. if (ret)
  180. return ret;
  181. channels->id = channel;
  182. channels->data = data;
  183. channels++;
  184. }
  185. return 0;
  186. }
  187. int adc_channels_single_shot(const char *name, unsigned int channel_mask,
  188. struct adc_channel *channels)
  189. {
  190. struct udevice *dev;
  191. int ret;
  192. ret = uclass_get_device_by_name(UCLASS_ADC, name, &dev);
  193. if (ret)
  194. return ret;
  195. ret = adc_start_channels(dev, channel_mask);
  196. if (ret)
  197. goto try_manual;
  198. ret = adc_channels_data(dev, channel_mask, channels);
  199. if (ret)
  200. return ret;
  201. return 0;
  202. try_manual:
  203. if (ret != -ENOSYS)
  204. return ret;
  205. return _adc_channels_single_shot(dev, channel_mask, channels);
  206. }
  207. static int adc_vdd_platdata_update(struct udevice *dev)
  208. {
  209. struct adc_uclass_platdata *uc_pdata = dev_get_uclass_platdata(dev);
  210. int ret;
  211. /* Warning!
  212. * This function can't return supply device before its bind.
  213. * Please pay attention to proper fdt scan sequence. If ADC device
  214. * will bind before its supply regulator device, then the below 'get'
  215. * will return an error.
  216. */
  217. if (!uc_pdata->vdd_supply)
  218. return 0;
  219. ret = regulator_get_value(uc_pdata->vdd_supply);
  220. if (ret < 0)
  221. return ret;
  222. uc_pdata->vdd_microvolts = ret;
  223. return 0;
  224. }
  225. static int adc_vss_platdata_update(struct udevice *dev)
  226. {
  227. struct adc_uclass_platdata *uc_pdata = dev_get_uclass_platdata(dev);
  228. int ret;
  229. if (!uc_pdata->vss_supply)
  230. return 0;
  231. ret = regulator_get_value(uc_pdata->vss_supply);
  232. if (ret < 0)
  233. return ret;
  234. uc_pdata->vss_microvolts = ret;
  235. return 0;
  236. }
  237. int adc_vdd_value(struct udevice *dev, int *uV)
  238. {
  239. struct adc_uclass_platdata *uc_pdata = dev_get_uclass_platdata(dev);
  240. int ret, value_sign = uc_pdata->vdd_polarity_negative ? -1 : 1;
  241. /* Update the regulator Value. */
  242. ret = adc_vdd_platdata_update(dev);
  243. if (ret)
  244. return ret;
  245. if (uc_pdata->vdd_microvolts == -ENODATA)
  246. return -ENODATA;
  247. *uV = uc_pdata->vdd_microvolts * value_sign;
  248. return 0;
  249. }
  250. int adc_vss_value(struct udevice *dev, int *uV)
  251. {
  252. struct adc_uclass_platdata *uc_pdata = dev_get_uclass_platdata(dev);
  253. int ret, value_sign = uc_pdata->vss_polarity_negative ? -1 : 1;
  254. /* Update the regulator Value. */
  255. ret = adc_vss_platdata_update(dev);
  256. if (ret)
  257. return ret;
  258. if (uc_pdata->vss_microvolts == -ENODATA)
  259. return -ENODATA;
  260. *uV = uc_pdata->vss_microvolts * value_sign;
  261. return 0;
  262. }
  263. int adc_raw_to_uV(struct udevice *dev, unsigned int raw, int *uV)
  264. {
  265. unsigned int data_mask;
  266. int ret, val, vref;
  267. u64 raw64 = raw;
  268. ret = adc_vdd_value(dev, &vref);
  269. if (ret)
  270. return ret;
  271. if (!adc_vss_value(dev, &val))
  272. vref -= val;
  273. ret = adc_data_mask(dev, &data_mask);
  274. if (ret)
  275. return ret;
  276. raw64 *= vref;
  277. do_div(raw64, data_mask);
  278. *uV = raw64;
  279. return 0;
  280. }
  281. static int adc_vdd_platdata_set(struct udevice *dev)
  282. {
  283. struct adc_uclass_platdata *uc_pdata = dev_get_uclass_platdata(dev);
  284. int ret;
  285. char *prop;
  286. prop = "vdd-polarity-negative";
  287. uc_pdata->vdd_polarity_negative = dev_read_bool(dev, prop);
  288. /* Optionally get regulators */
  289. ret = device_get_supply_regulator(dev, "vdd-supply",
  290. &uc_pdata->vdd_supply);
  291. if (!ret)
  292. return adc_vdd_platdata_update(dev);
  293. if (ret != -ENOENT)
  294. return ret;
  295. /* No vdd-supply phandle. */
  296. prop = "vdd-microvolts";
  297. uc_pdata->vdd_microvolts = dev_read_u32_default(dev, prop, -ENODATA);
  298. return 0;
  299. }
  300. static int adc_vss_platdata_set(struct udevice *dev)
  301. {
  302. struct adc_uclass_platdata *uc_pdata = dev_get_uclass_platdata(dev);
  303. int ret;
  304. char *prop;
  305. prop = "vss-polarity-negative";
  306. uc_pdata->vss_polarity_negative = dev_read_bool(dev, prop);
  307. ret = device_get_supply_regulator(dev, "vss-supply",
  308. &uc_pdata->vss_supply);
  309. if (!ret)
  310. return adc_vss_platdata_update(dev);
  311. if (ret != -ENOENT)
  312. return ret;
  313. /* No vss-supply phandle. */
  314. prop = "vss-microvolts";
  315. uc_pdata->vss_microvolts = dev_read_u32_default(dev, prop, -ENODATA);
  316. return 0;
  317. }
  318. static int adc_pre_probe(struct udevice *dev)
  319. {
  320. int ret;
  321. /* Set ADC VDD platdata: polarity, uV, regulator (phandle). */
  322. ret = adc_vdd_platdata_set(dev);
  323. if (ret)
  324. pr_err("%s: Can't update Vdd. Error: %d", dev->name, ret);
  325. /* Set ADC VSS platdata: polarity, uV, regulator (phandle). */
  326. ret = adc_vss_platdata_set(dev);
  327. if (ret)
  328. pr_err("%s: Can't update Vss. Error: %d", dev->name, ret);
  329. return 0;
  330. }
  331. UCLASS_DRIVER(adc) = {
  332. .id = UCLASS_ADC,
  333. .name = "adc",
  334. .pre_probe = adc_pre_probe,
  335. .per_device_platdata_auto_alloc_size = ADC_UCLASS_PLATDATA_SIZE,
  336. };