adc-uclass.c 9.4 KB

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