regulator.c 11 KB

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