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