drivers/regulator/devres.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * devres.c  --  Voltage/Current Regulator framework devres implementation.
   4  *
   5  * Copyright 2013 Linaro Ltd
   6  */
   7
   8 #include <linux/kernel.h>
   9 #include <linux/err.h>
  10 #include <linux/regmap.h>
  11 #include <linux/regulator/consumer.h>
  12 #include <linux/regulator/driver.h>
  13 #include <linux/module.h>
  14
  15 #include "internal.h"
  16
  17 static void devm_regulator_release(struct device *dev, void *res)
  18 {
  19         regulator_put(*(struct regulator **)res);
  20 }
  21
  22 static struct regulator *_devm_regulator_get(struct device *dev, const char *id,
  23                                              int get_type)
  24 {
  25         struct regulator **ptr, *regulator;
  26
  27         ptr = devres_alloc(devm_regulator_release, sizeof(*ptr), GFP_KERNEL);
  28         if (!ptr)
  29                 return ERR_PTR(-ENOMEM);
  30
  31         regulator = _regulator_get(dev, id, get_type);
  32         if (!IS_ERR(regulator)) {
  33                 *ptr = regulator;
  34                 devres_add(dev, ptr);
  35         } else {
  36                 devres_free(ptr);
  37         }
  38
  39         return regulator;
  40 }
  41
  42 /**
  43  * devm_regulator_get - Resource managed regulator_get()
  44  * @dev: device to supply
  45  * @id:  supply name or regulator ID.
  46  *
  47  * Managed regulator_get(). Regulators returned from this function are
  48  * automatically regulator_put() on driver detach. See regulator_get() for more
  49  * information.
  50  */
  51 struct regulator *devm_regulator_get(struct device *dev, const char *id)
  52 {
  53         return _devm_regulator_get(dev, id, NORMAL_GET);
  54 }
  55 EXPORT_SYMBOL_GPL(devm_regulator_get);
  56
  57 /**
  58  * devm_regulator_get_exclusive - Resource managed regulator_get_exclusive()
  59  * @dev: device to supply
  60  * @id:  supply name or regulator ID.
  61  *
  62  * Managed regulator_get_exclusive(). Regulators returned from this function
  63  * are automatically regulator_put() on driver detach. See regulator_get() for
  64  * more information.
  65  */
  66 struct regulator *devm_regulator_get_exclusive(struct device *dev,
  67                                                const char *id)
  68 {
  69         return _devm_regulator_get(dev, id, EXCLUSIVE_GET);
  70 }
  71 EXPORT_SYMBOL_GPL(devm_regulator_get_exclusive);
  72
  73 /**
  74  * devm_regulator_get_optional - Resource managed regulator_get_optional()
  75  * @dev: device to supply
  76  * @id:  supply name or regulator ID.
  77  *
  78  * Managed regulator_get_optional(). Regulators returned from this
  79  * function are automatically regulator_put() on driver detach. See
  80  * regulator_get_optional() for more information.
  81  */
  82 struct regulator *devm_regulator_get_optional(struct device *dev,
  83                                               const char *id)
  84 {
  85         return _devm_regulator_get(dev, id, OPTIONAL_GET);
  86 }
  87 EXPORT_SYMBOL_GPL(devm_regulator_get_optional);
  88
  89 static int devm_regulator_match(struct device *dev, void *res, void *data)
  90 {
  91         struct regulator **r = res;
  92         if (!r || !*r) {
  93                 WARN_ON(!r || !*r);
  94                 return 0;
  95         }
  96         return *r == data;
  97 }
  98
  99 /**
 100  * devm_regulator_put - Resource managed regulator_put()
 101  * @regulator: regulator to free
 102  *
 103  * Deallocate a regulator allocated with devm_regulator_get(). Normally
 104  * this function will not need to be called and the resource management
 105  * code will ensure that the resource is freed.
 106  */
 107 void devm_regulator_put(struct regulator *regulator)
 108 {
 109         int rc;
 110
 111         rc = devres_release(regulator->dev, devm_regulator_release,
 112                             devm_regulator_match, regulator);
 113         if (rc != 0)
 114                 WARN_ON(rc);
 115 }
 116 EXPORT_SYMBOL_GPL(devm_regulator_put);
 117
 118 struct regulator_bulk_devres {
 119         struct regulator_bulk_data *consumers;
 120         int num_consumers;
 121 };
 122
 123 static void devm_regulator_bulk_release(struct device *dev, void *res)
 124 {
 125         struct regulator_bulk_devres *devres = res;
 126
 127         regulator_bulk_free(devres->num_consumers, devres->consumers);
 128 }
 129
 130 /**
 131  * devm_regulator_bulk_get - managed get multiple regulator consumers
 132  *
 133  * @dev:           device to supply
 134  * @num_consumers: number of consumers to register
 135  * @consumers:     configuration of consumers; clients are stored here.
 136  *
 137  * @return 0 on success, an errno on failure.
 138  *
 139  * This helper function allows drivers to get several regulator
 140  * consumers in one operation with management, the regulators will
 141  * automatically be freed when the device is unbound.  If any of the
 142  * regulators cannot be acquired then any regulators that were
 143  * allocated will be freed before returning to the caller.
 144  */
 145 int devm_regulator_bulk_get(struct device *dev, int num_consumers,
 146                             struct regulator_bulk_data *consumers)
 147 {
 148         struct regulator_bulk_devres *devres;
 149         int ret;
 150
 151         devres = devres_alloc(devm_regulator_bulk_release,
 152                               sizeof(*devres), GFP_KERNEL);
 153         if (!devres)
 154                 return -ENOMEM;
 155
 156         ret = regulator_bulk_get(dev, num_consumers, consumers);
 157         if (!ret) {
 158                 devres->consumers = consumers;
 159                 devres->num_consumers = num_consumers;
 160                 devres_add(dev, devres);
 161         } else {
 162                 devres_free(devres);
 163         }
 164
 165         return ret;
 166 }
 167 EXPORT_SYMBOL_GPL(devm_regulator_bulk_get);
 168
 169 static void devm_rdev_release(struct device *dev, void *res)
 170 {
 171         regulator_unregister(*(struct regulator_dev **)res);
 172 }
 173
 174 /**
 175  * devm_regulator_register - Resource managed regulator_register()
 176  * @dev:            device to supply
 177  * @regulator_desc: regulator to register
 178  * @config:         runtime configuration for regulator
 179  *
 180  * Called by regulator drivers to register a regulator.  Returns a
 181  * valid pointer to struct regulator_dev on success or an ERR_PTR() on
 182  * error.  The regulator will automatically be released when the device
 183  * is unbound.
 184  */
 185 struct regulator_dev *devm_regulator_register(struct device *dev,
 186                                   const struct regulator_desc *regulator_desc,
 187                                   const struct regulator_config *config)
 188 {
 189         struct regulator_dev **ptr, *rdev;
 190
 191         ptr = devres_alloc(devm_rdev_release, sizeof(*ptr),
 192                            GFP_KERNEL);
 193         if (!ptr)
 194                 return ERR_PTR(-ENOMEM);
 195
 196         rdev = regulator_register(regulator_desc, config);
 197         if (!IS_ERR(rdev)) {
 198                 *ptr = rdev;
 199                 devres_add(dev, ptr);
 200         } else {
 201                 devres_free(ptr);
 202         }
 203
 204         return rdev;
 205 }
 206 EXPORT_SYMBOL_GPL(devm_regulator_register);
 207
 208 struct regulator_supply_alias_match {
 209         struct device *dev;
 210         const char *id;
 211 };
 212
 213 static int devm_regulator_match_supply_alias(struct device *dev, void *res,
 214                                              void *data)
 215 {
 216         struct regulator_supply_alias_match *match = res;
 217         struct regulator_supply_alias_match *target = data;
 218
 219         return match->dev == target->dev && strcmp(match->id, target->id) == 0;
 220 }
 221
 222 static void devm_regulator_destroy_supply_alias(struct device *dev, void *res)
 223 {
 224         struct regulator_supply_alias_match *match = res;
 225
 226         regulator_unregister_supply_alias(match->dev, match->id);
 227 }
 228
 229 /**
 230  * devm_regulator_register_supply_alias - Resource managed
 231  * regulator_register_supply_alias()
 232  *
 233  * @dev:       device to supply
 234  * @id:        supply name or regulator ID
 235  * @alias_dev: device that should be used to lookup the supply
 236  * @alias_id:  supply name or regulator ID that should be used to lookup the
 237  * supply
 238  *
 239  * The supply alias will automatically be unregistered when the source
 240  * device is unbound.
 241  */
 242 int devm_regulator_register_supply_alias(struct device *dev, const char *id,
 243                                          struct device *alias_dev,
 244                                          const char *alias_id)
 245 {
 246         struct regulator_supply_alias_match *match;
 247         int ret;
 248
 249         match = devres_alloc(devm_regulator_destroy_supply_alias,
 250                            sizeof(struct regulator_supply_alias_match),
 251                            GFP_KERNEL);
 252         if (!match)
 253                 return -ENOMEM;
 254
 255         match->dev = dev;
 256         match->id = id;
 257
 258         ret = regulator_register_supply_alias(dev, id, alias_dev, alias_id);
 259         if (ret < 0) {
 260                 devres_free(match);
 261                 return ret;
 262         }
 263
 264         devres_add(dev, match);
 265
 266         return 0;
 267 }
 268 EXPORT_SYMBOL_GPL(devm_regulator_register_supply_alias);
 269
 270 static void devm_regulator_unregister_supply_alias(struct device *dev,
 271                                                    const char *id)
 272 {
 273         struct regulator_supply_alias_match match;
 274         int rc;
 275
 276         match.dev = dev;
 277         match.id = id;
 278
 279         rc = devres_release(dev, devm_regulator_destroy_supply_alias,
 280                             devm_regulator_match_supply_alias, &match);
 281         if (rc != 0)
 282                 WARN_ON(rc);
 283 }
 284
 285 /**
 286  * devm_regulator_bulk_register_supply_alias - Managed register
 287  * multiple aliases
 288  *
 289  * @dev:       device to supply
 290  * @id:        list of supply names or regulator IDs
 291  * @alias_dev: device that should be used to lookup the supply
 292  * @alias_id:  list of supply names or regulator IDs that should be used to
 293  *             lookup the supply
 294  * @num_id:    number of aliases to register
 295  *
 296  * @return 0 on success, an errno on failure.
 297  *
 298  * This helper function allows drivers to register several supply
 299  * aliases in one operation, the aliases will be automatically
 300  * unregisters when the source device is unbound.  If any of the
 301  * aliases cannot be registered any aliases that were registered
 302  * will be removed before returning to the caller.
 303  */
 304 int devm_regulator_bulk_register_supply_alias(struct device *dev,
 305                                               const char *const *id,
 306                                               struct device *alias_dev,
 307                                               const char *const *alias_id,
 308                                               int num_id)
 309 {
 310         int i;
 311         int ret;
 312
 313         for (i = 0; i < num_id; ++i) {
 314                 ret = devm_regulator_register_supply_alias(dev, id[i],
 315                                                            alias_dev,
 316                                                            alias_id[i]);
 317                 if (ret < 0)
 318                         goto err;
 319         }
 320
 321         return 0;
 322
 323 err:
 324         dev_err(dev,
 325                 "Failed to create supply alias %s,%s -> %s,%s\n",
 326                 id[i], dev_name(dev), alias_id[i], dev_name(alias_dev));
 327
 328         while (--i >= 0)
 329                 devm_regulator_unregister_supply_alias(dev, id[i]);
 330
 331         return ret;
 332 }
 333 EXPORT_SYMBOL_GPL(devm_regulator_bulk_register_supply_alias);
 334
 335 struct regulator_notifier_match {
 336         struct regulator *regulator;
 337         struct notifier_block *nb;
 338 };
 339
 340 static int devm_regulator_match_notifier(struct device *dev, void *res,
 341                                          void *data)
 342 {
 343         struct regulator_notifier_match *match = res;
 344         struct regulator_notifier_match *target = data;
 345
 346         return match->regulator == target->regulator && match->nb == target->nb;
 347 }
 348
 349 static void devm_regulator_destroy_notifier(struct device *dev, void *res)
 350 {
 351         struct regulator_notifier_match *match = res;
 352
 353         regulator_unregister_notifier(match->regulator, match->nb);
 354 }
 355
 356 /**
 357  * devm_regulator_register_notifier - Resource managed
 358  * regulator_register_notifier
 359  *
 360  * @regulator: regulator source
 361  * @nb:        notifier block
 362  *
 363  * The notifier will be registers under the consumer device and be
 364  * automatically be unregistered when the source device is unbound.
 365  */
 366 int devm_regulator_register_notifier(struct regulator *regulator,
 367                                      struct notifier_block *nb)
 368 {
 369         struct regulator_notifier_match *match;
 370         int ret;
 371
 372         match = devres_alloc(devm_regulator_destroy_notifier,
 373                              sizeof(struct regulator_notifier_match),
 374                              GFP_KERNEL);
 375         if (!match)
 376                 return -ENOMEM;
 377
 378         match->regulator = regulator;
 379         match->nb = nb;
 380
 381         ret = regulator_register_notifier(regulator, nb);
 382         if (ret < 0) {
 383                 devres_free(match);
 384                 return ret;
 385         }
 386
 387         devres_add(regulator->dev, match);
 388
 389         return 0;
 390 }
 391 EXPORT_SYMBOL_GPL(devm_regulator_register_notifier);
 392
 393 /**
 394  * devm_regulator_unregister_notifier - Resource managed
 395  * regulator_unregister_notifier()
 396  *
 397  * @regulator: regulator source
 398  * @nb:        notifier block
 399  *
 400  * Unregister a notifier registered with devm_regulator_register_notifier().
 401  * Normally this function will not need to be called and the resource
 402  * management code will ensure that the resource is freed.
 403  */
 404 void devm_regulator_unregister_notifier(struct regulator *regulator,
 405                                         struct notifier_block *nb)
 406 {
 407         struct regulator_notifier_match match;
 408         int rc;
 409
 410         match.regulator = regulator;
 411         match.nb = nb;
 412
 413         rc = devres_release(regulator->dev, devm_regulator_destroy_notifier,
 414                             devm_regulator_match_notifier, &match);
 415         if (rc != 0)
 416                 WARN_ON(rc);
 417 }
 418 EXPORT_SYMBOL_GPL(devm_regulator_unregister_notifier);
 419
 420 static void regulator_irq_helper_drop(void *res)
 421 {
 422         regulator_irq_helper_cancel(&res);
 423 }
 424
 425 /**
 426  * devm_regulator_irq_helper - resource managed registration of IRQ based
 427  * regulator event/error notifier
 428  *
 429  * @dev:                device to which lifetime the helper's lifetime is
 430  *                      bound.
 431  * @d:                  IRQ helper descriptor.
 432  * @irq:                IRQ used to inform events/errors to be notified.
 433  * @irq_flags:          Extra IRQ flags to be OR'ed with the default
 434  *                      IRQF_ONESHOT when requesting the (threaded) irq.
 435  * @common_errs:        Errors which can be flagged by this IRQ for all rdevs.
 436  *                      When IRQ is re-enabled these errors will be cleared
 437  *                      from all associated regulators
 438  * @per_rdev_errs:      Optional error flag array describing errors specific
 439  *                      for only some of the regulators. These errors will be
 440  *                      or'ed with common errors. If this is given the array
 441  *                      should contain rdev_amount flags. Can be set to NULL
 442  *                      if there is no regulator specific error flags for this
 443  *                      IRQ.
 444  * @rdev:               Array of pointers to regulators associated with this
 445  *                      IRQ.
 446  * @rdev_amount:        Amount of regulators associated with this IRQ.
 447  *
 448  * Return: handle to irq_helper or an ERR_PTR() encoded error code.
 449  */
 450 void *devm_regulator_irq_helper(struct device *dev,
 451                                 const struct regulator_irq_desc *d, int irq,
 452                                 int irq_flags, int common_errs,
 453                                 int *per_rdev_errs,
 454                                 struct regulator_dev **rdev, int rdev_amount)
 455 {
 456         void *ptr;
 457         int ret;
 458
 459         ptr = regulator_irq_helper(dev, d, irq, irq_flags, common_errs,
 460                                     per_rdev_errs, rdev, rdev_amount);
 461         if (IS_ERR(ptr))
 462                 return ptr;
 463
 464         ret = devm_add_action_or_reset(dev, regulator_irq_helper_drop, ptr);
 465         if (ret)
 466                 return ERR_PTR(ret);
 467
 468         return ptr;
 469 }
 470 EXPORT_SYMBOL_GPL(devm_regulator_irq_helper);