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 static void regulator_action_disable(void *d)
  74 {
  75         struct regulator *r = (struct regulator *)d;
  76
  77         regulator_disable(r);
  78 }
  79
  80 static int _devm_regulator_get_enable(struct device *dev, const char *id,
  81                                       int get_type)
  82 {
  83         struct regulator *r;
  84         int ret;
  85
  86         r = _devm_regulator_get(dev, id, get_type);
  87         if (IS_ERR(r))
  88                 return PTR_ERR(r);
  89
  90         ret = regulator_enable(r);
  91         if (!ret)
  92                 ret = devm_add_action_or_reset(dev, &regulator_action_disable, r);
  93
  94         if (ret)
  95                 devm_regulator_put(r);
  96
  97         return ret;
  98 }
  99
 100 /**
 101  * devm_regulator_get_enable_optional - Resource managed regulator get and enable
 102  * @dev: device to supply
 103  * @id:  supply name or regulator ID.
 104  *
 105  * Get and enable regulator for duration of the device life-time.
 106  * regulator_disable() and regulator_put() are automatically called on driver
 107  * detach. See regulator_get_optional() and regulator_enable() for more
 108  * information.
 109  */
 110 int devm_regulator_get_enable_optional(struct device *dev, const char *id)
 111 {
 112         return _devm_regulator_get_enable(dev, id, OPTIONAL_GET);
 113 }
 114 EXPORT_SYMBOL_GPL(devm_regulator_get_enable_optional);
 115
 116 /**
 117  * devm_regulator_get_enable - Resource managed regulator get and enable
 118  * @dev: device to supply
 119  * @id:  supply name or regulator ID.
 120  *
 121  * Get and enable regulator for duration of the device life-time.
 122  * regulator_disable() and regulator_put() are automatically called on driver
 123  * detach. See regulator_get() and regulator_enable() for more
 124  * information.
 125  */
 126 int devm_regulator_get_enable(struct device *dev, const char *id)
 127 {
 128         return _devm_regulator_get_enable(dev, id, NORMAL_GET);
 129 }
 130 EXPORT_SYMBOL_GPL(devm_regulator_get_enable);
 131
 132 /**
 133  * devm_regulator_get_optional - Resource managed regulator_get_optional()
 134  * @dev: device to supply
 135  * @id:  supply name or regulator ID.
 136  *
 137  * Managed regulator_get_optional(). Regulators returned from this
 138  * function are automatically regulator_put() on driver detach. See
 139  * regulator_get_optional() for more information.
 140  */
 141 struct regulator *devm_regulator_get_optional(struct device *dev,
 142                                               const char *id)
 143 {
 144         return _devm_regulator_get(dev, id, OPTIONAL_GET);
 145 }
 146 EXPORT_SYMBOL_GPL(devm_regulator_get_optional);
 147
 148 static int devm_regulator_match(struct device *dev, void *res, void *data)
 149 {
 150         struct regulator **r = res;
 151         if (!r || !*r) {
 152                 WARN_ON(!r || !*r);
 153                 return 0;
 154         }
 155         return *r == data;
 156 }
 157
 158 /**
 159  * devm_regulator_put - Resource managed regulator_put()
 160  * @regulator: regulator to free
 161  *
 162  * Deallocate a regulator allocated with devm_regulator_get(). Normally
 163  * this function will not need to be called and the resource management
 164  * code will ensure that the resource is freed.
 165  */
 166 void devm_regulator_put(struct regulator *regulator)
 167 {
 168         int rc;
 169
 170         rc = devres_release(regulator->dev, devm_regulator_release,
 171                             devm_regulator_match, regulator);
 172         if (rc != 0)
 173                 WARN_ON(rc);
 174 }
 175 EXPORT_SYMBOL_GPL(devm_regulator_put);
 176
 177 struct regulator_bulk_devres {
 178         struct regulator_bulk_data *consumers;
 179         int num_consumers;
 180 };
 181
 182 static void devm_regulator_bulk_release(struct device *dev, void *res)
 183 {
 184         struct regulator_bulk_devres *devres = res;
 185
 186         regulator_bulk_free(devres->num_consumers, devres->consumers);
 187 }
 188
 189 static int _devm_regulator_bulk_get(struct device *dev, int num_consumers,
 190                                     struct regulator_bulk_data *consumers,
 191                                     enum regulator_get_type get_type)
 192 {
 193         struct regulator_bulk_devres *devres;
 194         int ret;
 195
 196         devres = devres_alloc(devm_regulator_bulk_release,
 197                               sizeof(*devres), GFP_KERNEL);
 198         if (!devres)
 199                 return -ENOMEM;
 200
 201         ret = _regulator_bulk_get(dev, num_consumers, consumers, get_type);
 202         if (!ret) {
 203                 devres->consumers = consumers;
 204                 devres->num_consumers = num_consumers;
 205                 devres_add(dev, devres);
 206         } else {
 207                 devres_free(devres);
 208         }
 209
 210         return ret;
 211 }
 212
 213 /**
 214  * devm_regulator_bulk_get - managed get multiple regulator consumers
 215  *
 216  * @dev:           device to supply
 217  * @num_consumers: number of consumers to register
 218  * @consumers:     configuration of consumers; clients are stored here.
 219  *
 220  * @return 0 on success, an errno on failure.
 221  *
 222  * This helper function allows drivers to get several regulator
 223  * consumers in one operation with management, the regulators will
 224  * automatically be freed when the device is unbound.  If any of the
 225  * regulators cannot be acquired then any regulators that were
 226  * allocated will be freed before returning to the caller.
 227  */
 228 int devm_regulator_bulk_get(struct device *dev, int num_consumers,
 229                             struct regulator_bulk_data *consumers)
 230 {
 231         return _devm_regulator_bulk_get(dev, num_consumers, consumers, NORMAL_GET);
 232 }
 233 EXPORT_SYMBOL_GPL(devm_regulator_bulk_get);
 234
 235 /**
 236  * devm_regulator_bulk_get_exclusive - managed exclusive get of multiple
 237  * regulator consumers
 238  *
 239  * @dev:           device to supply
 240  * @num_consumers: number of consumers to register
 241  * @consumers:     configuration of consumers; clients are stored here.
 242  *
 243  * @return 0 on success, an errno on failure.
 244  *
 245  * This helper function allows drivers to exclusively get several
 246  * regulator consumers in one operation with management, the regulators
 247  * will automatically be freed when the device is unbound.  If any of
 248  * the regulators cannot be acquired then any regulators that were
 249  * allocated will be freed before returning to the caller.
 250  */
 251 int devm_regulator_bulk_get_exclusive(struct device *dev, int num_consumers,
 252                                       struct regulator_bulk_data *consumers)
 253 {
 254         return _devm_regulator_bulk_get(dev, num_consumers, consumers, EXCLUSIVE_GET);
 255 }
 256 EXPORT_SYMBOL_GPL(devm_regulator_bulk_get_exclusive);
 257
 258 /**
 259  * devm_regulator_bulk_get_const - devm_regulator_bulk_get() w/ const data
 260  *
 261  * @dev:           device to supply
 262  * @num_consumers: number of consumers to register
 263  * @in_consumers:  const configuration of consumers
 264  * @out_consumers: in_consumers is copied here and this is passed to
 265  *                 devm_regulator_bulk_get().
 266  *
 267  * This is a convenience function to allow bulk regulator configuration
 268  * to be stored "static const" in files.
 269  *
 270  * Return: 0 on success, an errno on failure.
 271  */
 272 int devm_regulator_bulk_get_const(struct device *dev, int num_consumers,
 273                                   const struct regulator_bulk_data *in_consumers,
 274                                   struct regulator_bulk_data **out_consumers)
 275 {
 276         *out_consumers = devm_kmemdup(dev, in_consumers,
 277                                       num_consumers * sizeof(*in_consumers),
 278                                       GFP_KERNEL);
 279         if (*out_consumers == NULL)
 280                 return -ENOMEM;
 281
 282         return devm_regulator_bulk_get(dev, num_consumers, *out_consumers);
 283 }
 284 EXPORT_SYMBOL_GPL(devm_regulator_bulk_get_const);
 285
 286 static int devm_regulator_bulk_match(struct device *dev, void *res,
 287                                      void *data)
 288 {
 289         struct regulator_bulk_devres *match = res;
 290         struct regulator_bulk_data *target = data;
 291
 292         /*
 293          * We check the put uses same consumer list as the get did.
 294          * We _could_ scan all entries in consumer array and check the
 295          * regulators match but ATM I don't see the need. We can change this
 296          * later if needed.
 297          */
 298         return match->consumers == target;
 299 }
 300
 301 /**
 302  * devm_regulator_bulk_put - Resource managed regulator_bulk_put()
 303  * @consumers: consumers to free
 304  *
 305  * Deallocate regulators allocated with devm_regulator_bulk_get(). Normally
 306  * this function will not need to be called and the resource management
 307  * code will ensure that the resource is freed.
 308  */
 309 void devm_regulator_bulk_put(struct regulator_bulk_data *consumers)
 310 {
 311         int rc;
 312         struct regulator *regulator = consumers[0].consumer;
 313
 314         rc = devres_release(regulator->dev, devm_regulator_bulk_release,
 315                             devm_regulator_bulk_match, consumers);
 316         if (rc != 0)
 317                 WARN_ON(rc);
 318 }
 319 EXPORT_SYMBOL_GPL(devm_regulator_bulk_put);
 320
 321 static void devm_regulator_bulk_disable(void *res)
 322 {
 323         struct regulator_bulk_devres *devres = res;
 324         int i;
 325
 326         for (i = 0; i < devres->num_consumers; i++)
 327                 regulator_disable(devres->consumers[i].consumer);
 328 }
 329
 330 /**
 331  * devm_regulator_bulk_get_enable - managed get'n enable multiple regulators
 332  *
 333  * @dev:           device to supply
 334  * @num_consumers: number of consumers to register
 335  * @id:            list of supply names or regulator IDs
 336  *
 337  * @return 0 on success, an errno on failure.
 338  *
 339  * This helper function allows drivers to get several regulator
 340  * consumers in one operation with management, the regulators will
 341  * automatically be freed when the device is unbound.  If any of the
 342  * regulators cannot be acquired then any regulators that were
 343  * allocated will be freed before returning to the caller.
 344  */
 345 int devm_regulator_bulk_get_enable(struct device *dev, int num_consumers,
 346                                    const char * const *id)
 347 {
 348         struct regulator_bulk_devres *devres;
 349         struct regulator_bulk_data *consumers;
 350         int i, ret;
 351
 352         devres = devm_kmalloc(dev, sizeof(*devres), GFP_KERNEL);
 353         if (!devres)
 354                 return -ENOMEM;
 355
 356         devres->consumers = devm_kcalloc(dev, num_consumers, sizeof(*consumers),
 357                                          GFP_KERNEL);
 358         consumers = devres->consumers;
 359         if (!consumers)
 360                 return -ENOMEM;
 361
 362         devres->num_consumers = num_consumers;
 363
 364         for (i = 0; i < num_consumers; i++)
 365                 consumers[i].supply = id[i];
 366
 367         ret = devm_regulator_bulk_get(dev, num_consumers, consumers);
 368         if (ret)
 369                 return ret;
 370
 371         for (i = 0; i < num_consumers; i++) {
 372                 ret = regulator_enable(consumers[i].consumer);
 373                 if (ret)
 374                         goto unwind;
 375         }
 376
 377         ret = devm_add_action(dev, devm_regulator_bulk_disable, devres);
 378         if (!ret)
 379                 return 0;
 380
 381 unwind:
 382         while (--i >= 0)
 383                 regulator_disable(consumers[i].consumer);
 384
 385         devm_regulator_bulk_put(consumers);
 386
 387         return ret;
 388 }
 389 EXPORT_SYMBOL_GPL(devm_regulator_bulk_get_enable);
 390
 391 static void devm_rdev_release(struct device *dev, void *res)
 392 {
 393         regulator_unregister(*(struct regulator_dev **)res);
 394 }
 395
 396 /**
 397  * devm_regulator_register - Resource managed regulator_register()
 398  * @dev:            device to supply
 399  * @regulator_desc: regulator to register
 400  * @config:         runtime configuration for regulator
 401  *
 402  * Called by regulator drivers to register a regulator.  Returns a
 403  * valid pointer to struct regulator_dev on success or an ERR_PTR() on
 404  * error.  The regulator will automatically be released when the device
 405  * is unbound.
 406  */
 407 struct regulator_dev *devm_regulator_register(struct device *dev,
 408                                   const struct regulator_desc *regulator_desc,
 409                                   const struct regulator_config *config)
 410 {
 411         struct regulator_dev **ptr, *rdev;
 412
 413         ptr = devres_alloc(devm_rdev_release, sizeof(*ptr),
 414                            GFP_KERNEL);
 415         if (!ptr)
 416                 return ERR_PTR(-ENOMEM);
 417
 418         rdev = regulator_register(dev, regulator_desc, config);
 419         if (!IS_ERR(rdev)) {
 420                 *ptr = rdev;
 421                 devres_add(dev, ptr);
 422         } else {
 423                 devres_free(ptr);
 424         }
 425
 426         return rdev;
 427 }
 428 EXPORT_SYMBOL_GPL(devm_regulator_register);
 429
 430 struct regulator_supply_alias_match {
 431         struct device *dev;
 432         const char *id;
 433 };
 434
 435 static int devm_regulator_match_supply_alias(struct device *dev, void *res,
 436                                              void *data)
 437 {
 438         struct regulator_supply_alias_match *match = res;
 439         struct regulator_supply_alias_match *target = data;
 440
 441         return match->dev == target->dev && strcmp(match->id, target->id) == 0;
 442 }
 443
 444 static void devm_regulator_destroy_supply_alias(struct device *dev, void *res)
 445 {
 446         struct regulator_supply_alias_match *match = res;
 447
 448         regulator_unregister_supply_alias(match->dev, match->id);
 449 }
 450
 451 /**
 452  * devm_regulator_register_supply_alias - Resource managed
 453  * regulator_register_supply_alias()
 454  *
 455  * @dev:       device to supply
 456  * @id:        supply name or regulator ID
 457  * @alias_dev: device that should be used to lookup the supply
 458  * @alias_id:  supply name or regulator ID that should be used to lookup the
 459  * supply
 460  *
 461  * The supply alias will automatically be unregistered when the source
 462  * device is unbound.
 463  */
 464 int devm_regulator_register_supply_alias(struct device *dev, const char *id,
 465                                          struct device *alias_dev,
 466                                          const char *alias_id)
 467 {
 468         struct regulator_supply_alias_match *match;
 469         int ret;
 470
 471         match = devres_alloc(devm_regulator_destroy_supply_alias,
 472                            sizeof(struct regulator_supply_alias_match),
 473                            GFP_KERNEL);
 474         if (!match)
 475                 return -ENOMEM;
 476
 477         match->dev = dev;
 478         match->id = id;
 479
 480         ret = regulator_register_supply_alias(dev, id, alias_dev, alias_id);
 481         if (ret < 0) {
 482                 devres_free(match);
 483                 return ret;
 484         }
 485
 486         devres_add(dev, match);
 487
 488         return 0;
 489 }
 490 EXPORT_SYMBOL_GPL(devm_regulator_register_supply_alias);
 491
 492 static void devm_regulator_unregister_supply_alias(struct device *dev,
 493                                                    const char *id)
 494 {
 495         struct regulator_supply_alias_match match;
 496         int rc;
 497
 498         match.dev = dev;
 499         match.id = id;
 500
 501         rc = devres_release(dev, devm_regulator_destroy_supply_alias,
 502                             devm_regulator_match_supply_alias, &match);
 503         if (rc != 0)
 504                 WARN_ON(rc);
 505 }
 506
 507 /**
 508  * devm_regulator_bulk_register_supply_alias - Managed register
 509  * multiple aliases
 510  *
 511  * @dev:       device to supply
 512  * @id:        list of supply names or regulator IDs
 513  * @alias_dev: device that should be used to lookup the supply
 514  * @alias_id:  list of supply names or regulator IDs that should be used to
 515  *             lookup the supply
 516  * @num_id:    number of aliases to register
 517  *
 518  * @return 0 on success, an errno on failure.
 519  *
 520  * This helper function allows drivers to register several supply
 521  * aliases in one operation, the aliases will be automatically
 522  * unregisters when the source device is unbound.  If any of the
 523  * aliases cannot be registered any aliases that were registered
 524  * will be removed before returning to the caller.
 525  */
 526 int devm_regulator_bulk_register_supply_alias(struct device *dev,
 527                                               const char *const *id,
 528                                               struct device *alias_dev,
 529                                               const char *const *alias_id,
 530                                               int num_id)
 531 {
 532         int i;
 533         int ret;
 534
 535         for (i = 0; i < num_id; ++i) {
 536                 ret = devm_regulator_register_supply_alias(dev, id[i],
 537                                                            alias_dev,
 538                                                            alias_id[i]);
 539                 if (ret < 0)
 540                         goto err;
 541         }
 542
 543         return 0;
 544
 545 err:
 546         dev_err(dev,
 547                 "Failed to create supply alias %s,%s -> %s,%s\n",
 548                 id[i], dev_name(dev), alias_id[i], dev_name(alias_dev));
 549
 550         while (--i >= 0)
 551                 devm_regulator_unregister_supply_alias(dev, id[i]);
 552
 553         return ret;
 554 }
 555 EXPORT_SYMBOL_GPL(devm_regulator_bulk_register_supply_alias);
 556
 557 struct regulator_notifier_match {
 558         struct regulator *regulator;
 559         struct notifier_block *nb;
 560 };
 561
 562 static int devm_regulator_match_notifier(struct device *dev, void *res,
 563                                          void *data)
 564 {
 565         struct regulator_notifier_match *match = res;
 566         struct regulator_notifier_match *target = data;
 567
 568         return match->regulator == target->regulator && match->nb == target->nb;
 569 }
 570
 571 static void devm_regulator_destroy_notifier(struct device *dev, void *res)
 572 {
 573         struct regulator_notifier_match *match = res;
 574
 575         regulator_unregister_notifier(match->regulator, match->nb);
 576 }
 577
 578 /**
 579  * devm_regulator_register_notifier - Resource managed
 580  * regulator_register_notifier
 581  *
 582  * @regulator: regulator source
 583  * @nb:        notifier block
 584  *
 585  * The notifier will be registers under the consumer device and be
 586  * automatically be unregistered when the source device is unbound.
 587  */
 588 int devm_regulator_register_notifier(struct regulator *regulator,
 589                                      struct notifier_block *nb)
 590 {
 591         struct regulator_notifier_match *match;
 592         int ret;
 593
 594         match = devres_alloc(devm_regulator_destroy_notifier,
 595                              sizeof(struct regulator_notifier_match),
 596                              GFP_KERNEL);
 597         if (!match)
 598                 return -ENOMEM;
 599
 600         match->regulator = regulator;
 601         match->nb = nb;
 602
 603         ret = regulator_register_notifier(regulator, nb);
 604         if (ret < 0) {
 605                 devres_free(match);
 606                 return ret;
 607         }
 608
 609         devres_add(regulator->dev, match);
 610
 611         return 0;
 612 }
 613 EXPORT_SYMBOL_GPL(devm_regulator_register_notifier);
 614
 615 /**
 616  * devm_regulator_unregister_notifier - Resource managed
 617  * regulator_unregister_notifier()
 618  *
 619  * @regulator: regulator source
 620  * @nb:        notifier block
 621  *
 622  * Unregister a notifier registered with devm_regulator_register_notifier().
 623  * Normally this function will not need to be called and the resource
 624  * management code will ensure that the resource is freed.
 625  */
 626 void devm_regulator_unregister_notifier(struct regulator *regulator,
 627                                         struct notifier_block *nb)
 628 {
 629         struct regulator_notifier_match match;
 630         int rc;
 631
 632         match.regulator = regulator;
 633         match.nb = nb;
 634
 635         rc = devres_release(regulator->dev, devm_regulator_destroy_notifier,
 636                             devm_regulator_match_notifier, &match);
 637         if (rc != 0)
 638                 WARN_ON(rc);
 639 }
 640 EXPORT_SYMBOL_GPL(devm_regulator_unregister_notifier);
 641
 642 static void regulator_irq_helper_drop(void *res)
 643 {
 644         regulator_irq_helper_cancel(&res);
 645 }
 646
 647 /**
 648  * devm_regulator_irq_helper - resource managed registration of IRQ based
 649  * regulator event/error notifier
 650  *
 651  * @dev:                device to which lifetime the helper's lifetime is
 652  *                      bound.
 653  * @d:                  IRQ helper descriptor.
 654  * @irq:                IRQ used to inform events/errors to be notified.
 655  * @irq_flags:          Extra IRQ flags to be OR'ed with the default
 656  *                      IRQF_ONESHOT when requesting the (threaded) irq.
 657  * @common_errs:        Errors which can be flagged by this IRQ for all rdevs.
 658  *                      When IRQ is re-enabled these errors will be cleared
 659  *                      from all associated regulators
 660  * @per_rdev_errs:      Optional error flag array describing errors specific
 661  *                      for only some of the regulators. These errors will be
 662  *                      or'ed with common errors. If this is given the array
 663  *                      should contain rdev_amount flags. Can be set to NULL
 664  *                      if there is no regulator specific error flags for this
 665  *                      IRQ.
 666  * @rdev:               Array of pointers to regulators associated with this
 667  *                      IRQ.
 668  * @rdev_amount:        Amount of regulators associated with this IRQ.
 669  *
 670  * Return: handle to irq_helper or an ERR_PTR() encoded error code.
 671  */
 672 void *devm_regulator_irq_helper(struct device *dev,
 673                                 const struct regulator_irq_desc *d, int irq,
 674                                 int irq_flags, int common_errs,
 675                                 int *per_rdev_errs,
 676                                 struct regulator_dev **rdev, int rdev_amount)
 677 {
 678         void *ptr;
 679         int ret;
 680
 681         ptr = regulator_irq_helper(dev, d, irq, irq_flags, common_errs,
 682                                     per_rdev_errs, rdev, rdev_amount);
 683         if (IS_ERR(ptr))
 684                 return ptr;
 685
 686         ret = devm_add_action_or_reset(dev, regulator_irq_helper_drop, ptr);
 687         if (ret)
 688                 return ERR_PTR(ret);
 689
 690         return ptr;
 691 }
 692 EXPORT_SYMBOL_GPL(devm_regulator_irq_helper);