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 static int devm_rdev_match(struct device *dev, void *res, void *data)
 209 {
 210         struct regulator_dev **r = res;
 211         if (!r || !*r) {
 212                 WARN_ON(!r || !*r);
 213                 return 0;
 214         }
 215         return *r == data;
 216 }
 217
 218 /**
 219  * devm_regulator_unregister - Resource managed regulator_unregister()
 220  * @dev:  device to supply
 221  * @rdev: regulator to free
 222  *
 223  * Unregister a regulator registered with devm_regulator_register().
 224  * Normally this function will not need to be called and the resource
 225  * management code will ensure that the resource is freed.
 226  */
 227 void devm_regulator_unregister(struct device *dev, struct regulator_dev *rdev)
 228 {
 229         int rc;
 230
 231         rc = devres_release(dev, devm_rdev_release, devm_rdev_match, rdev);
 232         if (rc != 0)
 233                 WARN_ON(rc);
 234 }
 235 EXPORT_SYMBOL_GPL(devm_regulator_unregister);
 236
 237 struct regulator_supply_alias_match {
 238         struct device *dev;
 239         const char *id;
 240 };
 241
 242 static int devm_regulator_match_supply_alias(struct device *dev, void *res,
 243                                              void *data)
 244 {
 245         struct regulator_supply_alias_match *match = res;
 246         struct regulator_supply_alias_match *target = data;
 247
 248         return match->dev == target->dev && strcmp(match->id, target->id) == 0;
 249 }
 250
 251 static void devm_regulator_destroy_supply_alias(struct device *dev, void *res)
 252 {
 253         struct regulator_supply_alias_match *match = res;
 254
 255         regulator_unregister_supply_alias(match->dev, match->id);
 256 }
 257
 258 /**
 259  * devm_regulator_register_supply_alias - Resource managed
 260  * regulator_register_supply_alias()
 261  *
 262  * @dev:       device to supply
 263  * @id:        supply name or regulator ID
 264  * @alias_dev: device that should be used to lookup the supply
 265  * @alias_id:  supply name or regulator ID that should be used to lookup the
 266  * supply
 267  *
 268  * The supply alias will automatically be unregistered when the source
 269  * device is unbound.
 270  */
 271 int devm_regulator_register_supply_alias(struct device *dev, const char *id,
 272                                          struct device *alias_dev,
 273                                          const char *alias_id)
 274 {
 275         struct regulator_supply_alias_match *match;
 276         int ret;
 277
 278         match = devres_alloc(devm_regulator_destroy_supply_alias,
 279                            sizeof(struct regulator_supply_alias_match),
 280                            GFP_KERNEL);
 281         if (!match)
 282                 return -ENOMEM;
 283
 284         match->dev = dev;
 285         match->id = id;
 286
 287         ret = regulator_register_supply_alias(dev, id, alias_dev, alias_id);
 288         if (ret < 0) {
 289                 devres_free(match);
 290                 return ret;
 291         }
 292
 293         devres_add(dev, match);
 294
 295         return 0;
 296 }
 297 EXPORT_SYMBOL_GPL(devm_regulator_register_supply_alias);
 298
 299 /**
 300  * devm_regulator_unregister_supply_alias - Resource managed
 301  * regulator_unregister_supply_alias()
 302  *
 303  * @dev: device to supply
 304  * @id:  supply name or regulator ID
 305  *
 306  * Unregister an alias registered with
 307  * devm_regulator_register_supply_alias(). Normally this function
 308  * will not need to be called and the resource management code
 309  * will ensure that the resource is freed.
 310  */
 311 void devm_regulator_unregister_supply_alias(struct device *dev, const char *id)
 312 {
 313         struct regulator_supply_alias_match match;
 314         int rc;
 315
 316         match.dev = dev;
 317         match.id = id;
 318
 319         rc = devres_release(dev, devm_regulator_destroy_supply_alias,
 320                             devm_regulator_match_supply_alias, &match);
 321         if (rc != 0)
 322                 WARN_ON(rc);
 323 }
 324 EXPORT_SYMBOL_GPL(devm_regulator_unregister_supply_alias);
 325
 326 /**
 327  * devm_regulator_bulk_register_supply_alias - Managed register
 328  * multiple aliases
 329  *
 330  * @dev:       device to supply
 331  * @id:        list of supply names or regulator IDs
 332  * @alias_dev: device that should be used to lookup the supply
 333  * @alias_id:  list of supply names or regulator IDs that should be used to
 334  *             lookup the supply
 335  * @num_id:    number of aliases to register
 336  *
 337  * @return 0 on success, an errno on failure.
 338  *
 339  * This helper function allows drivers to register several supply
 340  * aliases in one operation, the aliases will be automatically
 341  * unregisters when the source device is unbound.  If any of the
 342  * aliases cannot be registered any aliases that were registered
 343  * will be removed before returning to the caller.
 344  */
 345 int devm_regulator_bulk_register_supply_alias(struct device *dev,
 346                                               const char *const *id,
 347                                               struct device *alias_dev,
 348                                               const char *const *alias_id,
 349                                               int num_id)
 350 {
 351         int i;
 352         int ret;
 353
 354         for (i = 0; i < num_id; ++i) {
 355                 ret = devm_regulator_register_supply_alias(dev, id[i],
 356                                                            alias_dev,
 357                                                            alias_id[i]);
 358                 if (ret < 0)
 359                         goto err;
 360         }
 361
 362         return 0;
 363
 364 err:
 365         dev_err(dev,
 366                 "Failed to create supply alias %s,%s -> %s,%s\n",
 367                 id[i], dev_name(dev), alias_id[i], dev_name(alias_dev));
 368
 369         while (--i >= 0)
 370                 devm_regulator_unregister_supply_alias(dev, id[i]);
 371
 372         return ret;
 373 }
 374 EXPORT_SYMBOL_GPL(devm_regulator_bulk_register_supply_alias);
 375
 376 /**
 377  * devm_regulator_bulk_unregister_supply_alias - Managed unregister
 378  * multiple aliases
 379  *
 380  * @dev:    device to supply
 381  * @id:     list of supply names or regulator IDs
 382  * @num_id: number of aliases to unregister
 383  *
 384  * Unregister aliases registered with
 385  * devm_regulator_bulk_register_supply_alias(). Normally this function
 386  * will not need to be called and the resource management code
 387  * will ensure that the resource is freed.
 388  */
 389 void devm_regulator_bulk_unregister_supply_alias(struct device *dev,
 390                                                  const char *const *id,
 391                                                  int num_id)
 392 {
 393         int i;
 394
 395         for (i = 0; i < num_id; ++i)
 396                 devm_regulator_unregister_supply_alias(dev, id[i]);
 397 }
 398 EXPORT_SYMBOL_GPL(devm_regulator_bulk_unregister_supply_alias);
 399
 400 struct regulator_notifier_match {
 401         struct regulator *regulator;
 402         struct notifier_block *nb;
 403 };
 404
 405 static int devm_regulator_match_notifier(struct device *dev, void *res,
 406                                          void *data)
 407 {
 408         struct regulator_notifier_match *match = res;
 409         struct regulator_notifier_match *target = data;
 410
 411         return match->regulator == target->regulator && match->nb == target->nb;
 412 }
 413
 414 static void devm_regulator_destroy_notifier(struct device *dev, void *res)
 415 {
 416         struct regulator_notifier_match *match = res;
 417
 418         regulator_unregister_notifier(match->regulator, match->nb);
 419 }
 420
 421 /**
 422  * devm_regulator_register_notifier - Resource managed
 423  * regulator_register_notifier
 424  *
 425  * @regulator: regulator source
 426  * @nb:        notifier block
 427  *
 428  * The notifier will be registers under the consumer device and be
 429  * automatically be unregistered when the source device is unbound.
 430  */
 431 int devm_regulator_register_notifier(struct regulator *regulator,
 432                                      struct notifier_block *nb)
 433 {
 434         struct regulator_notifier_match *match;
 435         int ret;
 436
 437         match = devres_alloc(devm_regulator_destroy_notifier,
 438                              sizeof(struct regulator_notifier_match),
 439                              GFP_KERNEL);
 440         if (!match)
 441                 return -ENOMEM;
 442
 443         match->regulator = regulator;
 444         match->nb = nb;
 445
 446         ret = regulator_register_notifier(regulator, nb);
 447         if (ret < 0) {
 448                 devres_free(match);
 449                 return ret;
 450         }
 451
 452         devres_add(regulator->dev, match);
 453
 454         return 0;
 455 }
 456 EXPORT_SYMBOL_GPL(devm_regulator_register_notifier);
 457
 458 /**
 459  * devm_regulator_unregister_notifier - Resource managed
 460  * regulator_unregister_notifier()
 461  *
 462  * @regulator: regulator source
 463  * @nb:        notifier block
 464  *
 465  * Unregister a notifier registered with devm_regulator_register_notifier().
 466  * Normally this function will not need to be called and the resource
 467  * management code will ensure that the resource is freed.
 468  */
 469 void devm_regulator_unregister_notifier(struct regulator *regulator,
 470                                         struct notifier_block *nb)
 471 {
 472         struct regulator_notifier_match match;
 473         int rc;
 474
 475         match.regulator = regulator;
 476         match.nb = nb;
 477
 478         rc = devres_release(regulator->dev, devm_regulator_destroy_notifier,
 479                             devm_regulator_match_notifier, &match);
 480         if (rc != 0)
 481                 WARN_ON(rc);
 482 }
 483 EXPORT_SYMBOL_GPL(devm_regulator_unregister_notifier);