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 DECLARE_GLOBAL_DATA_PTR;
  16
  17 int regulator_mode(struct udevice *dev, struct dm_regulator_mode **modep)
  18 {
  19         struct dm_regulator_uclass_platdata *uc_pdata;
  20
  21         *modep = NULL;
  22
  23         uc_pdata = dev_get_uclass_platdata(dev);
  24         if (!uc_pdata)
  25                 return -ENXIO;
  26
  27         *modep = uc_pdata->mode;
  28         return uc_pdata->mode_count;
  29 }
  30
  31 int regulator_get_value(struct udevice *dev)
  32 {
  33         const struct dm_regulator_ops *ops = dev_get_driver_ops(dev);
  34
  35         if (!ops || !ops->get_value)
  36                 return -ENOSYS;
  37
  38         return ops->get_value(dev);
  39 }
  40
  41 int regulator_set_value(struct udevice *dev, int uV)
  42 {
  43         const struct dm_regulator_ops *ops = dev_get_driver_ops(dev);
  44         struct dm_regulator_uclass_platdata *uc_pdata;
  45
  46         uc_pdata = dev_get_uclass_platdata(dev);
  47         if (uc_pdata->min_uV != -ENODATA && uV < uc_pdata->min_uV)
  48                 return -EINVAL;
  49         if (uc_pdata->max_uV != -ENODATA && uV > uc_pdata->max_uV)
  50                 return -EINVAL;
  51
  52         if (!ops || !ops->set_value)
  53                 return -ENOSYS;
  54
  55         return ops->set_value(dev, uV);
  56 }
  57
  58 /*
  59  * To be called with at most caution as there is no check
  60  * before setting the actual voltage value.
  61  */
  62 int regulator_set_value_force(struct udevice *dev, int uV)
  63 {
  64         const struct dm_regulator_ops *ops = dev_get_driver_ops(dev);
  65
  66         if (!ops || !ops->set_value)
  67                 return -ENOSYS;
  68
  69         return ops->set_value(dev, uV);
  70 }
  71
  72 int regulator_get_current(struct udevice *dev)
  73 {
  74         const struct dm_regulator_ops *ops = dev_get_driver_ops(dev);
  75
  76         if (!ops || !ops->get_current)
  77                 return -ENOSYS;
  78
  79         return ops->get_current(dev);
  80 }
  81
  82 int regulator_set_current(struct udevice *dev, int uA)
  83 {
  84         const struct dm_regulator_ops *ops = dev_get_driver_ops(dev);
  85         struct dm_regulator_uclass_platdata *uc_pdata;
  86
  87         uc_pdata = dev_get_uclass_platdata(dev);
  88         if (uc_pdata->min_uA != -ENODATA && uA < uc_pdata->min_uA)
  89                 return -EINVAL;
  90         if (uc_pdata->max_uA != -ENODATA && uA > uc_pdata->max_uA)
  91                 return -EINVAL;
  92
  93         if (!ops || !ops->set_current)
  94                 return -ENOSYS;
  95
  96         return ops->set_current(dev, uA);
  97 }
  98
  99 bool regulator_get_enable(struct udevice *dev)
 100 {
 101         const struct dm_regulator_ops *ops = dev_get_driver_ops(dev);
 102
 103         if (!ops || !ops->get_enable)
 104                 return -ENOSYS;
 105
 106         return ops->get_enable(dev);
 107 }
 108
 109 int regulator_set_enable(struct udevice *dev, bool enable)
 110 {
 111         const struct dm_regulator_ops *ops = dev_get_driver_ops(dev);
 112
 113         if (!ops || !ops->set_enable)
 114                 return -ENOSYS;
 115
 116         return ops->set_enable(dev, enable);
 117 }
 118
 119 int regulator_get_mode(struct udevice *dev)
 120 {
 121         const struct dm_regulator_ops *ops = dev_get_driver_ops(dev);
 122
 123         if (!ops || !ops->get_mode)
 124                 return -ENOSYS;
 125
 126         return ops->get_mode(dev);
 127 }
 128
 129 int regulator_set_mode(struct udevice *dev, int mode)
 130 {
 131         const struct dm_regulator_ops *ops = dev_get_driver_ops(dev);
 132
 133         if (!ops || !ops->set_mode)
 134                 return -ENOSYS;
 135
 136         return ops->set_mode(dev, mode);
 137 }
 138
 139 int regulator_get_by_platname(const char *plat_name, struct udevice **devp)
 140 {
 141         struct dm_regulator_uclass_platdata *uc_pdata;
 142         struct udevice *dev;
 143         int ret;
 144
 145         *devp = NULL;
 146
 147         for (ret = uclass_find_first_device(UCLASS_REGULATOR, &dev); dev;
 148              ret = uclass_find_next_device(&dev)) {
 149                 if (ret)
 150                         continue;
 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\n", __func__, plat_name);
 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!", platname);
 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 };