drivers/regulator/devres.c

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