test/dm/regulator.c

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