LXR uboot/test/dm/regulator.c

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