adc-uclass.c 9.3 KB

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