drivers/power/regulator/regulator-uclass.c

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