regulator-uclass.c 13 KB

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