regulator-uclass.c 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * Copyright (C) 2014-2015 Samsung Electronics
  4. * Przemyslaw Marczak <p.marczak@samsung.com>
  5. */
  6. #include <common.h>
  7. #include <errno.h>
  8. #include <dm.h>
  9. #include <log.h>
  10. #include <dm/uclass-internal.h>
  11. #include <linux/delay.h>
  12. #include <power/pmic.h>
  13. #include <power/regulator.h>
  14. int regulator_mode(struct udevice *dev, struct dm_regulator_mode **modep)
  15. {
  16. struct dm_regulator_uclass_platdata *uc_pdata;
  17. *modep = NULL;
  18. uc_pdata = dev_get_uclass_platdata(dev);
  19. if (!uc_pdata)
  20. return -ENXIO;
  21. *modep = uc_pdata->mode;
  22. return uc_pdata->mode_count;
  23. }
  24. int regulator_get_value(struct udevice *dev)
  25. {
  26. const struct dm_regulator_ops *ops = dev_get_driver_ops(dev);
  27. if (!ops || !ops->get_value)
  28. return -ENOSYS;
  29. return ops->get_value(dev);
  30. }
  31. static void regulator_set_value_ramp_delay(struct udevice *dev, int old_uV,
  32. int new_uV, unsigned int ramp_delay)
  33. {
  34. int delay = DIV_ROUND_UP(abs(new_uV - old_uV), ramp_delay);
  35. debug("regulator %s: delay %u us (%d uV -> %d uV)\n", dev->name, delay,
  36. old_uV, new_uV);
  37. udelay(delay);
  38. }
  39. int regulator_set_value(struct udevice *dev, int uV)
  40. {
  41. const struct dm_regulator_ops *ops = dev_get_driver_ops(dev);
  42. struct dm_regulator_uclass_platdata *uc_pdata;
  43. int ret, old_uV = uV, is_enabled = 0;
  44. uc_pdata = dev_get_uclass_platdata(dev);
  45. if (uc_pdata->min_uV != -ENODATA && uV < uc_pdata->min_uV)
  46. return -EINVAL;
  47. if (uc_pdata->max_uV != -ENODATA && uV > uc_pdata->max_uV)
  48. return -EINVAL;
  49. if (!ops || !ops->set_value)
  50. return -ENOSYS;
  51. if (uc_pdata->ramp_delay) {
  52. is_enabled = regulator_get_enable(dev);
  53. old_uV = regulator_get_value(dev);
  54. }
  55. ret = ops->set_value(dev, uV);
  56. if (!ret) {
  57. if (uc_pdata->ramp_delay && old_uV > 0 && is_enabled)
  58. regulator_set_value_ramp_delay(dev, old_uV, uV,
  59. uc_pdata->ramp_delay);
  60. }
  61. return ret;
  62. }
  63. int regulator_set_suspend_value(struct udevice *dev, int uV)
  64. {
  65. const struct dm_regulator_ops *ops = dev_get_driver_ops(dev);
  66. struct dm_regulator_uclass_platdata *uc_pdata;
  67. uc_pdata = dev_get_uclass_platdata(dev);
  68. if (uc_pdata->min_uV != -ENODATA && uV < uc_pdata->min_uV)
  69. return -EINVAL;
  70. if (uc_pdata->max_uV != -ENODATA && uV > uc_pdata->max_uV)
  71. return -EINVAL;
  72. if (!ops->set_suspend_value)
  73. return -ENOSYS;
  74. return ops->set_suspend_value(dev, uV);
  75. }
  76. int regulator_get_suspend_value(struct udevice *dev)
  77. {
  78. const struct dm_regulator_ops *ops = dev_get_driver_ops(dev);
  79. if (!ops->get_suspend_value)
  80. return -ENOSYS;
  81. return ops->get_suspend_value(dev);
  82. }
  83. /*
  84. * To be called with at most caution as there is no check
  85. * before setting the actual voltage value.
  86. */
  87. int regulator_set_value_force(struct udevice *dev, int uV)
  88. {
  89. const struct dm_regulator_ops *ops = dev_get_driver_ops(dev);
  90. if (!ops || !ops->set_value)
  91. return -ENOSYS;
  92. return ops->set_value(dev, uV);
  93. }
  94. int regulator_get_current(struct udevice *dev)
  95. {
  96. const struct dm_regulator_ops *ops = dev_get_driver_ops(dev);
  97. if (!ops || !ops->get_current)
  98. return -ENOSYS;
  99. return ops->get_current(dev);
  100. }
  101. int regulator_set_current(struct udevice *dev, int uA)
  102. {
  103. const struct dm_regulator_ops *ops = dev_get_driver_ops(dev);
  104. struct dm_regulator_uclass_platdata *uc_pdata;
  105. uc_pdata = dev_get_uclass_platdata(dev);
  106. if (uc_pdata->min_uA != -ENODATA && uA < uc_pdata->min_uA)
  107. return -EINVAL;
  108. if (uc_pdata->max_uA != -ENODATA && uA > uc_pdata->max_uA)
  109. return -EINVAL;
  110. if (!ops || !ops->set_current)
  111. return -ENOSYS;
  112. return ops->set_current(dev, uA);
  113. }
  114. int regulator_get_enable(struct udevice *dev)
  115. {
  116. const struct dm_regulator_ops *ops = dev_get_driver_ops(dev);
  117. if (!ops || !ops->get_enable)
  118. return -ENOSYS;
  119. return ops->get_enable(dev);
  120. }
  121. int regulator_set_enable(struct udevice *dev, bool enable)
  122. {
  123. const struct dm_regulator_ops *ops = dev_get_driver_ops(dev);
  124. struct dm_regulator_uclass_platdata *uc_pdata;
  125. int ret, old_enable = 0;
  126. if (!ops || !ops->set_enable)
  127. return -ENOSYS;
  128. uc_pdata = dev_get_uclass_platdata(dev);
  129. if (!enable && uc_pdata->always_on)
  130. return -EACCES;
  131. if (uc_pdata->ramp_delay)
  132. old_enable = regulator_get_enable(dev);
  133. ret = ops->set_enable(dev, enable);
  134. if (!ret) {
  135. if (uc_pdata->ramp_delay && !old_enable && enable) {
  136. int uV = regulator_get_value(dev);
  137. if (uV > 0) {
  138. regulator_set_value_ramp_delay(dev, 0, uV,
  139. uc_pdata->ramp_delay);
  140. }
  141. }
  142. }
  143. return ret;
  144. }
  145. int regulator_set_enable_if_allowed(struct udevice *dev, bool enable)
  146. {
  147. int ret;
  148. ret = regulator_set_enable(dev, enable);
  149. if (ret == -ENOSYS || ret == -EACCES)
  150. return 0;
  151. return ret;
  152. }
  153. int regulator_set_suspend_enable(struct udevice *dev, bool enable)
  154. {
  155. const struct dm_regulator_ops *ops = dev_get_driver_ops(dev);
  156. if (!ops->set_suspend_enable)
  157. return -ENOSYS;
  158. return ops->set_suspend_enable(dev, enable);
  159. }
  160. int regulator_get_suspend_enable(struct udevice *dev)
  161. {
  162. const struct dm_regulator_ops *ops = dev_get_driver_ops(dev);
  163. if (!ops->get_suspend_enable)
  164. return -ENOSYS;
  165. return ops->get_suspend_enable(dev);
  166. }
  167. int regulator_get_mode(struct udevice *dev)
  168. {
  169. const struct dm_regulator_ops *ops = dev_get_driver_ops(dev);
  170. if (!ops || !ops->get_mode)
  171. return -ENOSYS;
  172. return ops->get_mode(dev);
  173. }
  174. int regulator_set_mode(struct udevice *dev, int mode)
  175. {
  176. const struct dm_regulator_ops *ops = dev_get_driver_ops(dev);
  177. if (!ops || !ops->set_mode)
  178. return -ENOSYS;
  179. return ops->set_mode(dev, mode);
  180. }
  181. int regulator_get_by_platname(const char *plat_name, struct udevice **devp)
  182. {
  183. struct dm_regulator_uclass_platdata *uc_pdata;
  184. struct udevice *dev;
  185. int ret;
  186. *devp = NULL;
  187. for (ret = uclass_find_first_device(UCLASS_REGULATOR, &dev); dev;
  188. ret = uclass_find_next_device(&dev)) {
  189. if (ret) {
  190. debug("regulator %s, ret=%d\n", dev->name, ret);
  191. continue;
  192. }
  193. uc_pdata = dev_get_uclass_platdata(dev);
  194. if (!uc_pdata || strcmp(plat_name, uc_pdata->name))
  195. continue;
  196. return uclass_get_device_tail(dev, 0, devp);
  197. }
  198. debug("%s: can't find: %s, ret=%d\n", __func__, plat_name, ret);
  199. return -ENODEV;
  200. }
  201. int regulator_get_by_devname(const char *devname, struct udevice **devp)
  202. {
  203. return uclass_get_device_by_name(UCLASS_REGULATOR, devname, devp);
  204. }
  205. int device_get_supply_regulator(struct udevice *dev, const char *supply_name,
  206. struct udevice **devp)
  207. {
  208. return uclass_get_device_by_phandle(UCLASS_REGULATOR, dev,
  209. supply_name, devp);
  210. }
  211. int regulator_autoset(struct udevice *dev)
  212. {
  213. struct dm_regulator_uclass_platdata *uc_pdata;
  214. int ret = 0;
  215. uc_pdata = dev_get_uclass_platdata(dev);
  216. ret = regulator_set_suspend_enable(dev, uc_pdata->suspend_on);
  217. if (!ret && uc_pdata->suspend_on) {
  218. ret = regulator_set_suspend_value(dev, uc_pdata->suspend_uV);
  219. if (!ret)
  220. return ret;
  221. }
  222. if (!uc_pdata->always_on && !uc_pdata->boot_on)
  223. return -EMEDIUMTYPE;
  224. if (uc_pdata->type == REGULATOR_TYPE_FIXED)
  225. return regulator_set_enable(dev, true);
  226. if (uc_pdata->flags & REGULATOR_FLAG_AUTOSET_UV)
  227. ret = regulator_set_value(dev, uc_pdata->min_uV);
  228. if (uc_pdata->init_uV > 0)
  229. ret = regulator_set_value(dev, uc_pdata->init_uV);
  230. if (!ret && (uc_pdata->flags & REGULATOR_FLAG_AUTOSET_UA))
  231. ret = regulator_set_current(dev, uc_pdata->min_uA);
  232. if (!ret)
  233. ret = regulator_set_enable(dev, true);
  234. return ret;
  235. }
  236. static void regulator_show(struct udevice *dev, int ret)
  237. {
  238. struct dm_regulator_uclass_platdata *uc_pdata;
  239. uc_pdata = dev_get_uclass_platdata(dev);
  240. printf("%s@%s: ", dev->name, uc_pdata->name);
  241. if (uc_pdata->flags & REGULATOR_FLAG_AUTOSET_UV)
  242. printf("set %d uV", uc_pdata->min_uV);
  243. if (uc_pdata->flags & REGULATOR_FLAG_AUTOSET_UA)
  244. printf("; set %d uA", uc_pdata->min_uA);
  245. printf("; enabling");
  246. if (ret)
  247. printf(" (ret: %d)", ret);
  248. printf("\n");
  249. }
  250. int regulator_autoset_by_name(const char *platname, struct udevice **devp)
  251. {
  252. struct udevice *dev;
  253. int ret;
  254. ret = regulator_get_by_platname(platname, &dev);
  255. if (devp)
  256. *devp = dev;
  257. if (ret) {
  258. debug("Can get the regulator: %s (err=%d)\n", platname, ret);
  259. return ret;
  260. }
  261. return regulator_autoset(dev);
  262. }
  263. int regulator_list_autoset(const char *list_platname[],
  264. struct udevice *list_devp[],
  265. bool verbose)
  266. {
  267. struct udevice *dev;
  268. int error = 0, i = 0, ret;
  269. while (list_platname[i]) {
  270. ret = regulator_autoset_by_name(list_platname[i], &dev);
  271. if (ret != -EMEDIUMTYPE && verbose)
  272. regulator_show(dev, ret);
  273. if (ret & !error)
  274. error = ret;
  275. if (list_devp)
  276. list_devp[i] = dev;
  277. i++;
  278. }
  279. return error;
  280. }
  281. static bool regulator_name_is_unique(struct udevice *check_dev,
  282. const char *check_name)
  283. {
  284. struct dm_regulator_uclass_platdata *uc_pdata;
  285. struct udevice *dev;
  286. int check_len = strlen(check_name);
  287. int ret;
  288. int len;
  289. for (ret = uclass_find_first_device(UCLASS_REGULATOR, &dev); dev;
  290. ret = uclass_find_next_device(&dev)) {
  291. if (ret || dev == check_dev)
  292. continue;
  293. uc_pdata = dev_get_uclass_platdata(dev);
  294. len = strlen(uc_pdata->name);
  295. if (len != check_len)
  296. continue;
  297. if (!strcmp(uc_pdata->name, check_name))
  298. return false;
  299. }
  300. return true;
  301. }
  302. static int regulator_post_bind(struct udevice *dev)
  303. {
  304. struct dm_regulator_uclass_platdata *uc_pdata;
  305. const char *property = "regulator-name";
  306. uc_pdata = dev_get_uclass_platdata(dev);
  307. /* Regulator's mandatory constraint */
  308. uc_pdata->name = dev_read_string(dev, property);
  309. if (!uc_pdata->name) {
  310. debug("%s: dev '%s' has no property '%s'\n",
  311. __func__, dev->name, property);
  312. uc_pdata->name = dev_read_name(dev);
  313. if (!uc_pdata->name)
  314. return -EINVAL;
  315. }
  316. if (regulator_name_is_unique(dev, uc_pdata->name))
  317. return 0;
  318. debug("'%s' of dev: '%s', has nonunique value: '%s\n",
  319. property, dev->name, uc_pdata->name);
  320. return -EINVAL;
  321. }
  322. static int regulator_pre_probe(struct udevice *dev)
  323. {
  324. struct dm_regulator_uclass_platdata *uc_pdata;
  325. ofnode node;
  326. uc_pdata = dev_get_uclass_platdata(dev);
  327. if (!uc_pdata)
  328. return -ENXIO;
  329. /* Regulator's optional constraints */
  330. uc_pdata->min_uV = dev_read_u32_default(dev, "regulator-min-microvolt",
  331. -ENODATA);
  332. uc_pdata->max_uV = dev_read_u32_default(dev, "regulator-max-microvolt",
  333. -ENODATA);
  334. uc_pdata->init_uV = dev_read_u32_default(dev, "regulator-init-microvolt",
  335. -ENODATA);
  336. uc_pdata->min_uA = dev_read_u32_default(dev, "regulator-min-microamp",
  337. -ENODATA);
  338. uc_pdata->max_uA = dev_read_u32_default(dev, "regulator-max-microamp",
  339. -ENODATA);
  340. uc_pdata->always_on = dev_read_bool(dev, "regulator-always-on");
  341. uc_pdata->boot_on = dev_read_bool(dev, "regulator-boot-on");
  342. uc_pdata->ramp_delay = dev_read_u32_default(dev, "regulator-ramp-delay",
  343. 0);
  344. node = dev_read_subnode(dev, "regulator-state-mem");
  345. if (ofnode_valid(node)) {
  346. uc_pdata->suspend_on = !ofnode_read_bool(node, "regulator-off-in-suspend");
  347. if (ofnode_read_u32(node, "regulator-suspend-microvolt", &uc_pdata->suspend_uV))
  348. uc_pdata->suspend_uV = uc_pdata->max_uV;
  349. } else {
  350. uc_pdata->suspend_on = true;
  351. uc_pdata->suspend_uV = uc_pdata->max_uV;
  352. }
  353. /* Those values are optional (-ENODATA if unset) */
  354. if ((uc_pdata->min_uV != -ENODATA) &&
  355. (uc_pdata->max_uV != -ENODATA) &&
  356. (uc_pdata->min_uV == uc_pdata->max_uV))
  357. uc_pdata->flags |= REGULATOR_FLAG_AUTOSET_UV;
  358. /* Those values are optional (-ENODATA if unset) */
  359. if ((uc_pdata->min_uA != -ENODATA) &&
  360. (uc_pdata->max_uA != -ENODATA) &&
  361. (uc_pdata->min_uA == uc_pdata->max_uA))
  362. uc_pdata->flags |= REGULATOR_FLAG_AUTOSET_UA;
  363. return 0;
  364. }
  365. int regulators_enable_boot_on(bool verbose)
  366. {
  367. struct udevice *dev;
  368. struct uclass *uc;
  369. int ret;
  370. ret = uclass_get(UCLASS_REGULATOR, &uc);
  371. if (ret)
  372. return ret;
  373. for (uclass_first_device(UCLASS_REGULATOR, &dev);
  374. dev;
  375. uclass_next_device(&dev)) {
  376. ret = regulator_autoset(dev);
  377. if (ret == -EMEDIUMTYPE) {
  378. ret = 0;
  379. continue;
  380. }
  381. if (verbose)
  382. regulator_show(dev, ret);
  383. if (ret == -ENOSYS)
  384. ret = 0;
  385. }
  386. return ret;
  387. }
  388. UCLASS_DRIVER(regulator) = {
  389. .id = UCLASS_REGULATOR,
  390. .name = "regulator",
  391. .post_bind = regulator_post_bind,
  392. .pre_probe = regulator_pre_probe,
  393. .per_device_platdata_auto_alloc_size =
  394. sizeof(struct dm_regulator_uclass_platdata),
  395. };