drivers/power/regulator/regulator-uclass.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright (C) 2014-2015 Samsung Electronics
   4  * Przemyslaw Marczak <p.marczak@samsung.com>
   5  */
   6
   7 #include <common.h>
   8 #include <errno.h>
   9 #include <dm.h>
  10 #include <dm/uclass-internal.h>
  11 #include <power/pmic.h>
  12 #include <power/regulator.h>
  13
  14 int regulator_mode(struct udevice *dev, struct dm_regulator_mode **modep)
  15 {
  16         struct dm_regulator_uclass_platdata *uc_pdata;
  17
  18         *modep = NULL;
  19
  20         uc_pdata = dev_get_uclass_platdata(dev);
  21         if (!uc_pdata)
  22                 return -ENXIO;
  23
  24         *modep = uc_pdata->mode;
  25         return uc_pdata->mode_count;
  26 }
  27
  28 int regulator_get_value(struct udevice *dev)
  29 {
  30         const struct dm_regulator_ops *ops = dev_get_driver_ops(dev);
  31
  32         if (!ops || !ops->get_value)
  33                 return -ENOSYS;
  34
  35         return ops->get_value(dev);
  36 }
  37
  38 int regulator_set_value(struct udevice *dev, int uV)
  39 {
  40         const struct dm_regulator_ops *ops = dev_get_driver_ops(dev);
  41         struct dm_regulator_uclass_platdata *uc_pdata;
  42
  43         uc_pdata = dev_get_uclass_platdata(dev);
  44         if (uc_pdata->min_uV != -ENODATA && uV < uc_pdata->min_uV)
  45                 return -EINVAL;
  46         if (uc_pdata->max_uV != -ENODATA && uV > uc_pdata->max_uV)
  47                 return -EINVAL;
  48
  49         if (!ops || !ops->set_value)
  50                 return -ENOSYS;
  51
  52         return ops->set_value(dev, uV);
  53 }
  54
  55 /*
  56  * To be called with at most caution as there is no check
  57  * before setting the actual voltage value.
  58  */
  59 int regulator_set_value_force(struct udevice *dev, int uV)
  60 {
  61         const struct dm_regulator_ops *ops = dev_get_driver_ops(dev);
  62
  63         if (!ops || !ops->set_value)
  64                 return -ENOSYS;
  65
  66         return ops->set_value(dev, uV);
  67 }
  68
  69 int regulator_get_current(struct udevice *dev)
  70 {
  71         const struct dm_regulator_ops *ops = dev_get_driver_ops(dev);
  72
  73         if (!ops || !ops->get_current)
  74                 return -ENOSYS;
  75
  76         return ops->get_current(dev);
  77 }
  78
  79 int regulator_set_current(struct udevice *dev, int uA)
  80 {
  81         const struct dm_regulator_ops *ops = dev_get_driver_ops(dev);
  82         struct dm_regulator_uclass_platdata *uc_pdata;
  83
  84         uc_pdata = dev_get_uclass_platdata(dev);
  85         if (uc_pdata->min_uA != -ENODATA && uA < uc_pdata->min_uA)
  86                 return -EINVAL;
  87         if (uc_pdata->max_uA != -ENODATA && uA > uc_pdata->max_uA)
  88                 return -EINVAL;
  89
  90         if (!ops || !ops->set_current)
  91                 return -ENOSYS;
  92
  93         return ops->set_current(dev, uA);
  94 }
  95
  96 int regulator_get_enable(struct udevice *dev)
  97 {
  98         const struct dm_regulator_ops *ops = dev_get_driver_ops(dev);
  99
 100         if (!ops || !ops->get_enable)
 101                 return -ENOSYS;
 102
 103         return ops->get_enable(dev);
 104 }
 105
 106 int regulator_set_enable(struct udevice *dev, bool enable)
 107 {
 108         const struct dm_regulator_ops *ops = dev_get_driver_ops(dev);
 109         struct dm_regulator_uclass_platdata *uc_pdata;
 110
 111         if (!ops || !ops->set_enable)
 112                 return -ENOSYS;
 113
 114         uc_pdata = dev_get_uclass_platdata(dev);
 115         if (!enable && uc_pdata->always_on)
 116                 return -EACCES;
 117
 118         return ops->set_enable(dev, enable);
 119 }
 120
 121 int regulator_set_enable_if_allowed(struct udevice *dev, bool enable)
 122 {
 123         int ret;
 124
 125         ret = regulator_set_enable(dev, enable);
 126         if (ret == -ENOSYS || ret == -EACCES)
 127                 return 0;
 128
 129         return ret;
 130 }
 131
 132 int regulator_get_mode(struct udevice *dev)
 133 {
 134         const struct dm_regulator_ops *ops = dev_get_driver_ops(dev);
 135
 136         if (!ops || !ops->get_mode)
 137                 return -ENOSYS;
 138
 139         return ops->get_mode(dev);
 140 }
 141
 142 int regulator_set_mode(struct udevice *dev, int mode)
 143 {
 144         const struct dm_regulator_ops *ops = dev_get_driver_ops(dev);
 145
 146         if (!ops || !ops->set_mode)
 147                 return -ENOSYS;
 148
 149         return ops->set_mode(dev, mode);
 150 }
 151
 152 int regulator_get_by_platname(const char *plat_name, struct udevice **devp)
 153 {
 154         struct dm_regulator_uclass_platdata *uc_pdata;
 155         struct udevice *dev;
 156         int ret;
 157
 158         *devp = NULL;
 159
 160         for (ret = uclass_find_first_device(UCLASS_REGULATOR, &dev); dev;
 161              ret = uclass_find_next_device(&dev)) {
 162                 if (ret) {
 163                         debug("regulator %s, ret=%d\n", dev->name, ret);
 164                         continue;
 165                 }
 166
 167                 uc_pdata = dev_get_uclass_platdata(dev);
 168                 if (!uc_pdata || strcmp(plat_name, uc_pdata->name))
 169                         continue;
 170
 171                 return uclass_get_device_tail(dev, 0, devp);
 172         }
 173
 174         debug("%s: can't find: %s, ret=%d\n", __func__, plat_name, ret);
 175
 176         return -ENODEV;
 177 }
 178
 179 int regulator_get_by_devname(const char *devname, struct udevice **devp)
 180 {
 181         return uclass_get_device_by_name(UCLASS_REGULATOR, devname, devp);
 182 }
 183
 184 int device_get_supply_regulator(struct udevice *dev, const char *supply_name,
 185                                 struct udevice **devp)
 186 {
 187         return uclass_get_device_by_phandle(UCLASS_REGULATOR, dev,
 188                                             supply_name, devp);
 189 }
 190
 191 int regulator_autoset(struct udevice *dev)
 192 {
 193         struct dm_regulator_uclass_platdata *uc_pdata;
 194         int ret = 0;
 195
 196         uc_pdata = dev_get_uclass_platdata(dev);
 197         if (!uc_pdata->always_on && !uc_pdata->boot_on)
 198                 return -EMEDIUMTYPE;
 199
 200         if (uc_pdata->flags & REGULATOR_FLAG_AUTOSET_UV)
 201                 ret = regulator_set_value(dev, uc_pdata->min_uV);
 202         if (!ret && (uc_pdata->flags & REGULATOR_FLAG_AUTOSET_UA))
 203                 ret = regulator_set_current(dev, uc_pdata->min_uA);
 204
 205         if (!ret)
 206                 ret = regulator_set_enable(dev, true);
 207
 208         return ret;
 209 }
 210
 211 static void regulator_show(struct udevice *dev, int ret)
 212 {
 213         struct dm_regulator_uclass_platdata *uc_pdata;
 214
 215         uc_pdata = dev_get_uclass_platdata(dev);
 216
 217         printf("%s@%s: ", dev->name, uc_pdata->name);
 218         if (uc_pdata->flags & REGULATOR_FLAG_AUTOSET_UV)
 219                 printf("set %d uV", uc_pdata->min_uV);
 220         if (uc_pdata->flags & REGULATOR_FLAG_AUTOSET_UA)
 221                 printf("; set %d uA", uc_pdata->min_uA);
 222         printf("; enabling");
 223         if (ret)
 224                 printf(" (ret: %d)", ret);
 225         printf("\n");
 226 }
 227
 228 int regulator_autoset_by_name(const char *platname, struct udevice **devp)
 229 {
 230         struct udevice *dev;
 231         int ret;
 232
 233         ret = regulator_get_by_platname(platname, &dev);
 234         if (devp)
 235                 *devp = dev;
 236         if (ret) {
 237                 debug("Can get the regulator: %s (err=%d)\n", platname, ret);
 238                 return ret;
 239         }
 240
 241         return regulator_autoset(dev);
 242 }
 243
 244 int regulator_list_autoset(const char *list_platname[],
 245                            struct udevice *list_devp[],
 246                            bool verbose)
 247 {
 248         struct udevice *dev;
 249         int error = 0, i = 0, ret;
 250
 251         while (list_platname[i]) {
 252                 ret = regulator_autoset_by_name(list_platname[i], &dev);
 253                 if (ret != -EMEDIUMTYPE && verbose)
 254                         regulator_show(dev, ret);
 255                 if (ret & !error)
 256                         error = ret;
 257
 258                 if (list_devp)
 259                         list_devp[i] = dev;
 260
 261                 i++;
 262         }
 263
 264         return error;
 265 }
 266
 267 static bool regulator_name_is_unique(struct udevice *check_dev,
 268                                      const char *check_name)
 269 {
 270         struct dm_regulator_uclass_platdata *uc_pdata;
 271         struct udevice *dev;
 272         int check_len = strlen(check_name);
 273         int ret;
 274         int len;
 275
 276         for (ret = uclass_find_first_device(UCLASS_REGULATOR, &dev); dev;
 277              ret = uclass_find_next_device(&dev)) {
 278                 if (ret || dev == check_dev)
 279                         continue;
 280
 281                 uc_pdata = dev_get_uclass_platdata(dev);
 282                 len = strlen(uc_pdata->name);
 283                 if (len != check_len)
 284                         continue;
 285
 286                 if (!strcmp(uc_pdata->name, check_name))
 287                         return false;
 288         }
 289
 290         return true;
 291 }
 292
 293 static int regulator_post_bind(struct udevice *dev)
 294 {
 295         struct dm_regulator_uclass_platdata *uc_pdata;
 296         const char *property = "regulator-name";
 297
 298         uc_pdata = dev_get_uclass_platdata(dev);
 299
 300         /* Regulator's mandatory constraint */
 301         uc_pdata->name = dev_read_string(dev, property);
 302         if (!uc_pdata->name) {
 303                 debug("%s: dev '%s' has no property '%s'\n",
 304                       __func__, dev->name, property);
 305                 uc_pdata->name = dev_read_name(dev);
 306                 if (!uc_pdata->name)
 307                         return -EINVAL;
 308         }
 309
 310         if (regulator_name_is_unique(dev, uc_pdata->name))
 311                 return 0;
 312
 313         debug("'%s' of dev: '%s', has nonunique value: '%s\n",
 314               property, dev->name, uc_pdata->name);
 315
 316         return -EINVAL;
 317 }
 318
 319 static int regulator_pre_probe(struct udevice *dev)
 320 {
 321         struct dm_regulator_uclass_platdata *uc_pdata;
 322
 323         uc_pdata = dev_get_uclass_platdata(dev);
 324         if (!uc_pdata)
 325                 return -ENXIO;
 326
 327         /* Regulator's optional constraints */
 328         uc_pdata->min_uV = dev_read_u32_default(dev, "regulator-min-microvolt",
 329                                                 -ENODATA);
 330         uc_pdata->max_uV = dev_read_u32_default(dev, "regulator-max-microvolt",
 331                                                 -ENODATA);
 332         uc_pdata->min_uA = dev_read_u32_default(dev, "regulator-min-microamp",
 333                                                 -ENODATA);
 334         uc_pdata->max_uA = dev_read_u32_default(dev, "regulator-max-microamp",
 335                                                 -ENODATA);
 336         uc_pdata->always_on = dev_read_bool(dev, "regulator-always-on");
 337         uc_pdata->boot_on = dev_read_bool(dev, "regulator-boot-on");
 338
 339         /* Those values are optional (-ENODATA if unset) */
 340         if ((uc_pdata->min_uV != -ENODATA) &&
 341             (uc_pdata->max_uV != -ENODATA) &&
 342             (uc_pdata->min_uV == uc_pdata->max_uV))
 343                 uc_pdata->flags |= REGULATOR_FLAG_AUTOSET_UV;
 344
 345         /* Those values are optional (-ENODATA if unset) */
 346         if ((uc_pdata->min_uA != -ENODATA) &&
 347             (uc_pdata->max_uA != -ENODATA) &&
 348             (uc_pdata->min_uA == uc_pdata->max_uA))
 349                 uc_pdata->flags |= REGULATOR_FLAG_AUTOSET_UA;
 350
 351         return 0;
 352 }
 353
 354 int regulators_enable_boot_on(bool verbose)
 355 {
 356         struct udevice *dev;
 357         struct uclass *uc;
 358         int ret;
 359
 360         ret = uclass_get(UCLASS_REGULATOR, &uc);
 361         if (ret)
 362                 return ret;
 363         for (uclass_first_device(UCLASS_REGULATOR, &dev);
 364              dev;
 365              uclass_next_device(&dev)) {
 366                 ret = regulator_autoset(dev);
 367                 if (ret == -EMEDIUMTYPE) {
 368                         ret = 0;
 369                         continue;
 370                 }
 371                 if (verbose)
 372                         regulator_show(dev, ret);
 373                 if (ret == -ENOSYS)
 374                         ret = 0;
 375         }
 376
 377         return ret;
 378 }
 379
 380 UCLASS_DRIVER(regulator) = {
 381         .id             = UCLASS_REGULATOR,
 382         .name           = "regulator",
 383         .post_bind      = regulator_post_bind,
 384         .pre_probe      = regulator_pre_probe,
 385         .per_device_platdata_auto_alloc_size =
 386                                 sizeof(struct dm_regulator_uclass_platdata),
 387 };