regulator.c 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * Tests for the driver model regulator API
  4. *
  5. * Copyright (c) 2015 Samsung Electronics
  6. * Przemyslaw Marczak <p.marczak@samsung.com>
  7. */
  8. #include <common.h>
  9. #include <errno.h>
  10. #include <dm.h>
  11. #include <fdtdec.h>
  12. #include <log.h>
  13. #include <malloc.h>
  14. #include <dm/device-internal.h>
  15. #include <dm/root.h>
  16. #include <dm/util.h>
  17. #include <dm/test.h>
  18. #include <dm/uclass-internal.h>
  19. #include <power/pmic.h>
  20. #include <power/regulator.h>
  21. #include <power/sandbox_pmic.h>
  22. #include <test/test.h>
  23. #include <test/ut.h>
  24. enum {
  25. BUCK1,
  26. BUCK2,
  27. BUCK3,
  28. LDO1,
  29. LDO2,
  30. OUTPUT_COUNT,
  31. };
  32. enum {
  33. DEVNAME = 0,
  34. PLATNAME,
  35. OUTPUT_NAME_COUNT,
  36. };
  37. static const char *regulator_names[OUTPUT_COUNT][OUTPUT_NAME_COUNT] = {
  38. /* devname, platname */
  39. { SANDBOX_BUCK1_DEVNAME, SANDBOX_BUCK1_PLATNAME },
  40. { SANDBOX_BUCK2_DEVNAME, SANDBOX_BUCK2_PLATNAME },
  41. { SANDBOX_BUCK3_DEVNAME, SANDBOX_BUCK3_PLATNAME },
  42. { SANDBOX_LDO1_DEVNAME, SANDBOX_LDO1_PLATNAME},
  43. { SANDBOX_LDO2_DEVNAME, SANDBOX_LDO2_PLATNAME},
  44. };
  45. /* Test regulator get method */
  46. static int dm_test_power_regulator_get(struct unit_test_state *uts)
  47. {
  48. struct dm_regulator_uclass_platdata *uc_pdata;
  49. struct udevice *dev_by_devname;
  50. struct udevice *dev_by_platname;
  51. const char *devname;
  52. const char *platname;
  53. int i;
  54. for (i = 0; i < OUTPUT_COUNT; i++) {
  55. /*
  56. * Do the test for each regulator's devname and platname,
  57. * which are related to a single device.
  58. */
  59. devname = regulator_names[i][DEVNAME];
  60. platname = regulator_names[i][PLATNAME];
  61. /*
  62. * Check, that regulator_get_by_devname() function, returns
  63. * a device with the name equal to the requested one.
  64. */
  65. ut_assertok(regulator_get_by_devname(devname, &dev_by_devname));
  66. ut_asserteq_str(devname, dev_by_devname->name);
  67. /*
  68. * Check, that regulator_get_by_platname() function, returns
  69. * a device with the name equal to the requested one.
  70. */
  71. ut_assertok(regulator_get_by_platname(platname, &dev_by_platname));
  72. uc_pdata = dev_get_uclass_platdata(dev_by_platname);
  73. ut_assert(uc_pdata);
  74. ut_asserteq_str(platname, uc_pdata->name);
  75. /*
  76. * Check, that the pointers returned by both get functions,
  77. * points to the same regulator device.
  78. */
  79. ut_asserteq_ptr(dev_by_devname, dev_by_platname);
  80. }
  81. return 0;
  82. }
  83. DM_TEST(dm_test_power_regulator_get, UT_TESTF_SCAN_FDT);
  84. /* Test regulator set and get Voltage method */
  85. static int dm_test_power_regulator_set_get_voltage(struct unit_test_state *uts)
  86. {
  87. struct dm_regulator_uclass_platdata *uc_pdata;
  88. struct udevice *dev;
  89. const char *platname;
  90. int val_set, val_get;
  91. /* Set and get Voltage of BUCK1 - set to 'min' constraint */
  92. platname = regulator_names[BUCK1][PLATNAME];
  93. ut_assertok(regulator_get_by_platname(platname, &dev));
  94. uc_pdata = dev_get_uclass_platdata(dev);
  95. ut_assert(uc_pdata);
  96. val_set = uc_pdata->min_uV;
  97. ut_assertok(regulator_set_value(dev, val_set));
  98. val_get = regulator_get_value(dev);
  99. ut_assert(val_get >= 0);
  100. ut_asserteq(val_set, val_get);
  101. return 0;
  102. }
  103. DM_TEST(dm_test_power_regulator_set_get_voltage, UT_TESTF_SCAN_FDT);
  104. /* Test regulator set and get Current method */
  105. static int dm_test_power_regulator_set_get_current(struct unit_test_state *uts)
  106. {
  107. struct dm_regulator_uclass_platdata *uc_pdata;
  108. struct udevice *dev;
  109. const char *platname;
  110. int val_set, val_get;
  111. /* Set and get the Current of LDO1 - set to 'min' constraint */
  112. platname = regulator_names[LDO1][PLATNAME];
  113. ut_assertok(regulator_get_by_platname(platname, &dev));
  114. uc_pdata = dev_get_uclass_platdata(dev);
  115. ut_assert(uc_pdata);
  116. val_set = uc_pdata->min_uA;
  117. ut_assertok(regulator_set_current(dev, val_set));
  118. val_get = regulator_get_current(dev);
  119. ut_assert(val_get >= 0);
  120. ut_asserteq(val_set, val_get);
  121. /* Check LDO2 current limit constraints - should be -ENODATA */
  122. platname = regulator_names[LDO2][PLATNAME];
  123. ut_assertok(regulator_get_by_platname(platname, &dev));
  124. uc_pdata = dev_get_uclass_platdata(dev);
  125. ut_assert(uc_pdata);
  126. ut_asserteq(-ENODATA, uc_pdata->min_uA);
  127. ut_asserteq(-ENODATA, uc_pdata->max_uA);
  128. /* Try set the Current of LDO2 - should return -ENOSYS */
  129. ut_asserteq(-ENOSYS, regulator_set_current(dev, 0));
  130. return 0;
  131. }
  132. DM_TEST(dm_test_power_regulator_set_get_current, UT_TESTF_SCAN_FDT);
  133. /* Test regulator set and get Enable method */
  134. static int dm_test_power_regulator_set_get_enable(struct unit_test_state *uts)
  135. {
  136. const char *platname;
  137. struct udevice *dev;
  138. bool val_set = true;
  139. /* Set the Enable of LDO1 - default is disabled */
  140. platname = regulator_names[LDO1][PLATNAME];
  141. ut_assertok(regulator_get_by_platname(platname, &dev));
  142. ut_assertok(regulator_set_enable(dev, val_set));
  143. /* Get the Enable state of LDO1 and compare it with the requested one */
  144. ut_asserteq(regulator_get_enable(dev), val_set);
  145. return 0;
  146. }
  147. DM_TEST(dm_test_power_regulator_set_get_enable, UT_TESTF_SCAN_FDT);
  148. /* Test regulator set and get enable if allowed method */
  149. static
  150. int dm_test_power_regulator_set_enable_if_allowed(struct unit_test_state *uts)
  151. {
  152. const char *platname;
  153. struct udevice *dev, *dev_autoset;
  154. bool val_set = false;
  155. /* Get BUCK1 - always on regulator */
  156. platname = regulator_names[BUCK1][PLATNAME];
  157. ut_assertok(regulator_autoset_by_name(platname, &dev_autoset));
  158. ut_assertok(regulator_get_by_platname(platname, &dev));
  159. /* Try disabling always-on regulator */
  160. ut_assertok(regulator_set_enable_if_allowed(dev, val_set));
  161. ut_asserteq(regulator_get_enable(dev), !val_set);
  162. return 0;
  163. }
  164. DM_TEST(dm_test_power_regulator_set_enable_if_allowed, UT_TESTF_SCAN_FDT);
  165. /* Test regulator set and get mode method */
  166. static int dm_test_power_regulator_set_get_mode(struct unit_test_state *uts)
  167. {
  168. const char *platname;
  169. struct udevice *dev;
  170. int val_set = LDO_OM_SLEEP;
  171. /* Set the mode id to LDO_OM_SLEEP of LDO1 - default is LDO_OM_OFF */
  172. platname = regulator_names[LDO1][PLATNAME];
  173. ut_assertok(regulator_get_by_platname(platname, &dev));
  174. ut_assertok(regulator_set_mode(dev, val_set));
  175. /* Get the mode id of LDO1 and compare it with the requested one */
  176. ut_asserteq(regulator_get_mode(dev), val_set);
  177. return 0;
  178. }
  179. DM_TEST(dm_test_power_regulator_set_get_mode, UT_TESTF_SCAN_FDT);
  180. /* Test regulator set and get suspend Voltage method */
  181. static int dm_test_power_regulator_set_get_suspend_voltage(struct unit_test_state *uts)
  182. {
  183. struct dm_regulator_uclass_platdata *uc_pdata;
  184. const struct dm_regulator_ops *ops;
  185. struct udevice *dev;
  186. const char *platname;
  187. int val_set, val_get;
  188. /* Set and get Voltage of BUCK1 - set to 'min' constraint */
  189. platname = regulator_names[BUCK1][PLATNAME];
  190. ut_assertok(regulator_get_by_platname(platname, &dev));
  191. uc_pdata = dev_get_uclass_platdata(dev);
  192. ut_assert(uc_pdata);
  193. ops = dev_get_driver_ops(dev);
  194. if (ops->set_suspend_value && ops->get_suspend_value) {
  195. val_set = uc_pdata->suspend_uV;
  196. ut_assertok(regulator_set_suspend_value(dev, val_set));
  197. val_get = regulator_get_suspend_value(dev);
  198. ut_assert(val_get >= 0);
  199. ut_asserteq(val_set, val_get);
  200. }
  201. return 0;
  202. }
  203. DM_TEST(dm_test_power_regulator_set_get_suspend_voltage, UT_TESTF_SCAN_FDT);
  204. /* Test regulator set and get suspend Enable method */
  205. static int dm_test_power_regulator_set_get_suspend_enable(struct unit_test_state *uts)
  206. {
  207. const struct dm_regulator_ops *ops;
  208. const char *platname;
  209. struct udevice *dev;
  210. bool val_set = true;
  211. /* Set the Enable of LDO1 - default is disabled */
  212. platname = regulator_names[LDO1][PLATNAME];
  213. ut_assertok(regulator_get_by_platname(platname, &dev));
  214. ops = dev_get_driver_ops(dev);
  215. if (ops->set_suspend_enable && ops->get_suspend_enable) {
  216. ut_assertok(regulator_set_suspend_enable(dev, val_set));
  217. /*
  218. * Get the Enable state of LDO1 and
  219. * compare it with the requested one
  220. */
  221. ut_asserteq(regulator_get_suspend_enable(dev), val_set);
  222. }
  223. return 0;
  224. }
  225. DM_TEST(dm_test_power_regulator_set_get_suspend_enable, UT_TESTF_SCAN_FDT);
  226. /* Test regulator autoset method */
  227. static int dm_test_power_regulator_autoset(struct unit_test_state *uts)
  228. {
  229. const char *platname;
  230. struct udevice *dev, *dev_autoset;
  231. /*
  232. * Test the BUCK1 with fdt properties
  233. * - min-microvolt = max-microvolt = 1200000
  234. * - min-microamp = max-microamp = 200000
  235. * - always-on = set
  236. * - boot-on = not set
  237. * Expected output state: uV=1200000; uA=200000; output enabled
  238. */
  239. platname = regulator_names[BUCK1][PLATNAME];
  240. ut_assertok(regulator_autoset_by_name(platname, &dev_autoset));
  241. /* Check, that the returned device is proper */
  242. ut_assertok(regulator_get_by_platname(platname, &dev));
  243. ut_asserteq_ptr(dev, dev_autoset);
  244. /* Check the setup after autoset */
  245. ut_asserteq(regulator_get_value(dev),
  246. SANDBOX_BUCK1_AUTOSET_EXPECTED_UV);
  247. ut_asserteq(regulator_get_current(dev),
  248. SANDBOX_BUCK1_AUTOSET_EXPECTED_UA);
  249. ut_asserteq(regulator_get_enable(dev),
  250. SANDBOX_BUCK1_AUTOSET_EXPECTED_ENABLE);
  251. return 0;
  252. }
  253. DM_TEST(dm_test_power_regulator_autoset, UT_TESTF_SCAN_FDT);
  254. /*
  255. * Struct setting: to keep the expected output settings.
  256. * @voltage: Voltage value [uV]
  257. * @current: Current value [uA]
  258. * @enable: output enable state: true/false
  259. */
  260. struct setting {
  261. int voltage;
  262. int current;
  263. bool enable;
  264. };
  265. /*
  266. * platname_list: an array of regulator platform names.
  267. * For testing regulator_list_autoset() for outputs:
  268. * - LDO1
  269. * - LDO2
  270. */
  271. static const char *platname_list[] = {
  272. SANDBOX_LDO1_PLATNAME,
  273. SANDBOX_LDO2_PLATNAME,
  274. NULL,
  275. };
  276. /*
  277. * expected_setting_list: an array of regulator output setting, expected after
  278. * call of the regulator_list_autoset() for the "platname_list" array.
  279. * For testing results of regulator_list_autoset() for outputs:
  280. * - LDO1
  281. * - LDO2
  282. * The settings are defined in: include/power/sandbox_pmic.h
  283. */
  284. static const struct setting expected_setting_list[] = {
  285. [0] = { /* LDO1 */
  286. .voltage = SANDBOX_LDO1_AUTOSET_EXPECTED_UV,
  287. .current = SANDBOX_LDO1_AUTOSET_EXPECTED_UA,
  288. .enable = SANDBOX_LDO1_AUTOSET_EXPECTED_ENABLE,
  289. },
  290. [1] = { /* LDO2 */
  291. .voltage = SANDBOX_LDO2_AUTOSET_EXPECTED_UV,
  292. .current = SANDBOX_LDO2_AUTOSET_EXPECTED_UA,
  293. .enable = SANDBOX_LDO2_AUTOSET_EXPECTED_ENABLE,
  294. },
  295. };
  296. static int list_count = ARRAY_SIZE(expected_setting_list);
  297. /* Test regulator list autoset method */
  298. static int dm_test_power_regulator_autoset_list(struct unit_test_state *uts)
  299. {
  300. struct udevice *dev_list[2], *dev;
  301. int i;
  302. /*
  303. * Test the settings of the regulator list:
  304. * LDO1 with fdt properties:
  305. * - min-microvolt = max-microvolt = 1800000
  306. * - min-microamp = max-microamp = 100000
  307. * - always-on = not set
  308. * - boot-on = set
  309. * Expected output state: uV=1800000; uA=100000; output enabled
  310. *
  311. * LDO2 with fdt properties:
  312. * - min-microvolt = max-microvolt = 3300000
  313. * - always-on = not set
  314. * - boot-on = not set
  315. * Expected output state: uV=300000(default); output disabled(default)
  316. * The expected settings are defined in: include/power/sandbox_pmic.h.
  317. */
  318. ut_assertok(regulator_list_autoset(platname_list, dev_list, false));
  319. for (i = 0; i < list_count; i++) {
  320. /* Check, that the returned device is non-NULL */
  321. ut_assert(dev_list[i]);
  322. /* Check, that the returned device is proper */
  323. ut_assertok(regulator_get_by_platname(platname_list[i], &dev));
  324. ut_asserteq_ptr(dev_list[i], dev);
  325. /* Check, that regulator output Voltage value is as expected */
  326. ut_asserteq(regulator_get_value(dev_list[i]),
  327. expected_setting_list[i].voltage);
  328. /* Check, that regulator output Current value is as expected */
  329. ut_asserteq(regulator_get_current(dev_list[i]),
  330. expected_setting_list[i].current);
  331. /* Check, that regulator output Enable state is as expected */
  332. ut_asserteq(regulator_get_enable(dev_list[i]),
  333. expected_setting_list[i].enable);
  334. }
  335. return 0;
  336. }
  337. DM_TEST(dm_test_power_regulator_autoset_list, UT_TESTF_SCAN_FDT);