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