Merge tag 'for-6.1-rc3-tag' of git://git.kernel.org/pub/scm/linux/kernel/git/kdave...
[platform/kernel/linux-starfive.git] / 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 /**
190  * devm_regulator_bulk_get - managed get multiple regulator consumers
191  *
192  * @dev:           device to supply
193  * @num_consumers: number of consumers to register
194  * @consumers:     configuration of consumers; clients are stored here.
195  *
196  * @return 0 on success, an errno on failure.
197  *
198  * This helper function allows drivers to get several regulator
199  * consumers in one operation with management, the regulators will
200  * automatically be freed when the device is unbound.  If any of the
201  * regulators cannot be acquired then any regulators that were
202  * allocated will be freed before returning to the caller.
203  */
204 int devm_regulator_bulk_get(struct device *dev, int num_consumers,
205                             struct regulator_bulk_data *consumers)
206 {
207         struct regulator_bulk_devres *devres;
208         int ret;
209
210         devres = devres_alloc(devm_regulator_bulk_release,
211                               sizeof(*devres), GFP_KERNEL);
212         if (!devres)
213                 return -ENOMEM;
214
215         ret = regulator_bulk_get(dev, num_consumers, consumers);
216         if (!ret) {
217                 devres->consumers = consumers;
218                 devres->num_consumers = num_consumers;
219                 devres_add(dev, devres);
220         } else {
221                 devres_free(devres);
222         }
223
224         return ret;
225 }
226 EXPORT_SYMBOL_GPL(devm_regulator_bulk_get);
227
228 /**
229  * devm_regulator_bulk_get_const - devm_regulator_bulk_get() w/ const data
230  *
231  * @dev:           device to supply
232  * @num_consumers: number of consumers to register
233  * @in_consumers:  const configuration of consumers
234  * @out_consumers: in_consumers is copied here and this is passed to
235  *                 devm_regulator_bulk_get().
236  *
237  * This is a convenience function to allow bulk regulator configuration
238  * to be stored "static const" in files.
239  *
240  * Return: 0 on success, an errno on failure.
241  */
242 int devm_regulator_bulk_get_const(struct device *dev, int num_consumers,
243                                   const struct regulator_bulk_data *in_consumers,
244                                   struct regulator_bulk_data **out_consumers)
245 {
246         *out_consumers = devm_kmemdup(dev, in_consumers,
247                                       num_consumers * sizeof(*in_consumers),
248                                       GFP_KERNEL);
249         if (*out_consumers == NULL)
250                 return -ENOMEM;
251
252         return devm_regulator_bulk_get(dev, num_consumers, *out_consumers);
253 }
254 EXPORT_SYMBOL_GPL(devm_regulator_bulk_get_const);
255
256 static int devm_regulator_bulk_match(struct device *dev, void *res,
257                                      void *data)
258 {
259         struct regulator_bulk_devres *match = res;
260         struct regulator_bulk_data *target = data;
261
262         /*
263          * We check the put uses same consumer list as the get did.
264          * We _could_ scan all entries in consumer array and check the
265          * regulators match but ATM I don't see the need. We can change this
266          * later if needed.
267          */
268         return match->consumers == target;
269 }
270
271 /**
272  * devm_regulator_bulk_put - Resource managed regulator_bulk_put()
273  * @consumers: consumers to free
274  *
275  * Deallocate regulators allocated with devm_regulator_bulk_get(). Normally
276  * this function will not need to be called and the resource management
277  * code will ensure that the resource is freed.
278  */
279 void devm_regulator_bulk_put(struct regulator_bulk_data *consumers)
280 {
281         int rc;
282         struct regulator *regulator = consumers[0].consumer;
283
284         rc = devres_release(regulator->dev, devm_regulator_bulk_release,
285                             devm_regulator_bulk_match, consumers);
286         if (rc != 0)
287                 WARN_ON(rc);
288 }
289 EXPORT_SYMBOL_GPL(devm_regulator_bulk_put);
290
291 static void devm_regulator_bulk_disable(void *res)
292 {
293         struct regulator_bulk_devres *devres = res;
294         int i;
295
296         for (i = 0; i < devres->num_consumers; i++)
297                 regulator_disable(devres->consumers[i].consumer);
298 }
299
300 /**
301  * devm_regulator_bulk_get_enable - managed get'n enable multiple regulators
302  *
303  * @dev:           device to supply
304  * @num_consumers: number of consumers to register
305  * @id:            list of supply names or regulator IDs
306  *
307  * @return 0 on success, an errno on failure.
308  *
309  * This helper function allows drivers to get several regulator
310  * consumers in one operation with management, the regulators will
311  * automatically be freed when the device is unbound.  If any of the
312  * regulators cannot be acquired then any regulators that were
313  * allocated will be freed before returning to the caller.
314  */
315 int devm_regulator_bulk_get_enable(struct device *dev, int num_consumers,
316                                    const char * const *id)
317 {
318         struct regulator_bulk_devres *devres;
319         struct regulator_bulk_data *consumers;
320         int i, ret;
321
322         devres = devm_kmalloc(dev, sizeof(*devres), GFP_KERNEL);
323         if (!devres)
324                 return -ENOMEM;
325
326         devres->consumers = devm_kcalloc(dev, num_consumers, sizeof(*consumers),
327                                          GFP_KERNEL);
328         consumers = devres->consumers;
329         if (!consumers)
330                 return -ENOMEM;
331
332         devres->num_consumers = num_consumers;
333
334         for (i = 0; i < num_consumers; i++)
335                 consumers[i].supply = id[i];
336
337         ret = devm_regulator_bulk_get(dev, num_consumers, consumers);
338         if (ret)
339                 return ret;
340
341         for (i = 0; i < num_consumers; i++) {
342                 ret = regulator_enable(consumers[i].consumer);
343                 if (ret)
344                         goto unwind;
345         }
346
347         ret = devm_add_action(dev, devm_regulator_bulk_disable, devres);
348         if (!ret)
349                 return 0;
350
351 unwind:
352         while (--i >= 0)
353                 regulator_disable(consumers[i].consumer);
354
355         devm_regulator_bulk_put(consumers);
356
357         return ret;
358 }
359 EXPORT_SYMBOL_GPL(devm_regulator_bulk_get_enable);
360
361 static void devm_rdev_release(struct device *dev, void *res)
362 {
363         regulator_unregister(*(struct regulator_dev **)res);
364 }
365
366 /**
367  * devm_regulator_register - Resource managed regulator_register()
368  * @dev:            device to supply
369  * @regulator_desc: regulator to register
370  * @config:         runtime configuration for regulator
371  *
372  * Called by regulator drivers to register a regulator.  Returns a
373  * valid pointer to struct regulator_dev on success or an ERR_PTR() on
374  * error.  The regulator will automatically be released when the device
375  * is unbound.
376  */
377 struct regulator_dev *devm_regulator_register(struct device *dev,
378                                   const struct regulator_desc *regulator_desc,
379                                   const struct regulator_config *config)
380 {
381         struct regulator_dev **ptr, *rdev;
382
383         ptr = devres_alloc(devm_rdev_release, sizeof(*ptr),
384                            GFP_KERNEL);
385         if (!ptr)
386                 return ERR_PTR(-ENOMEM);
387
388         rdev = regulator_register(regulator_desc, config);
389         if (!IS_ERR(rdev)) {
390                 *ptr = rdev;
391                 devres_add(dev, ptr);
392         } else {
393                 devres_free(ptr);
394         }
395
396         return rdev;
397 }
398 EXPORT_SYMBOL_GPL(devm_regulator_register);
399
400 struct regulator_supply_alias_match {
401         struct device *dev;
402         const char *id;
403 };
404
405 static int devm_regulator_match_supply_alias(struct device *dev, void *res,
406                                              void *data)
407 {
408         struct regulator_supply_alias_match *match = res;
409         struct regulator_supply_alias_match *target = data;
410
411         return match->dev == target->dev && strcmp(match->id, target->id) == 0;
412 }
413
414 static void devm_regulator_destroy_supply_alias(struct device *dev, void *res)
415 {
416         struct regulator_supply_alias_match *match = res;
417
418         regulator_unregister_supply_alias(match->dev, match->id);
419 }
420
421 /**
422  * devm_regulator_register_supply_alias - Resource managed
423  * regulator_register_supply_alias()
424  *
425  * @dev:       device to supply
426  * @id:        supply name or regulator ID
427  * @alias_dev: device that should be used to lookup the supply
428  * @alias_id:  supply name or regulator ID that should be used to lookup the
429  * supply
430  *
431  * The supply alias will automatically be unregistered when the source
432  * device is unbound.
433  */
434 int devm_regulator_register_supply_alias(struct device *dev, const char *id,
435                                          struct device *alias_dev,
436                                          const char *alias_id)
437 {
438         struct regulator_supply_alias_match *match;
439         int ret;
440
441         match = devres_alloc(devm_regulator_destroy_supply_alias,
442                            sizeof(struct regulator_supply_alias_match),
443                            GFP_KERNEL);
444         if (!match)
445                 return -ENOMEM;
446
447         match->dev = dev;
448         match->id = id;
449
450         ret = regulator_register_supply_alias(dev, id, alias_dev, alias_id);
451         if (ret < 0) {
452                 devres_free(match);
453                 return ret;
454         }
455
456         devres_add(dev, match);
457
458         return 0;
459 }
460 EXPORT_SYMBOL_GPL(devm_regulator_register_supply_alias);
461
462 static void devm_regulator_unregister_supply_alias(struct device *dev,
463                                                    const char *id)
464 {
465         struct regulator_supply_alias_match match;
466         int rc;
467
468         match.dev = dev;
469         match.id = id;
470
471         rc = devres_release(dev, devm_regulator_destroy_supply_alias,
472                             devm_regulator_match_supply_alias, &match);
473         if (rc != 0)
474                 WARN_ON(rc);
475 }
476
477 /**
478  * devm_regulator_bulk_register_supply_alias - Managed register
479  * multiple aliases
480  *
481  * @dev:       device to supply
482  * @id:        list of supply names or regulator IDs
483  * @alias_dev: device that should be used to lookup the supply
484  * @alias_id:  list of supply names or regulator IDs that should be used to
485  *             lookup the supply
486  * @num_id:    number of aliases to register
487  *
488  * @return 0 on success, an errno on failure.
489  *
490  * This helper function allows drivers to register several supply
491  * aliases in one operation, the aliases will be automatically
492  * unregisters when the source device is unbound.  If any of the
493  * aliases cannot be registered any aliases that were registered
494  * will be removed before returning to the caller.
495  */
496 int devm_regulator_bulk_register_supply_alias(struct device *dev,
497                                               const char *const *id,
498                                               struct device *alias_dev,
499                                               const char *const *alias_id,
500                                               int num_id)
501 {
502         int i;
503         int ret;
504
505         for (i = 0; i < num_id; ++i) {
506                 ret = devm_regulator_register_supply_alias(dev, id[i],
507                                                            alias_dev,
508                                                            alias_id[i]);
509                 if (ret < 0)
510                         goto err;
511         }
512
513         return 0;
514
515 err:
516         dev_err(dev,
517                 "Failed to create supply alias %s,%s -> %s,%s\n",
518                 id[i], dev_name(dev), alias_id[i], dev_name(alias_dev));
519
520         while (--i >= 0)
521                 devm_regulator_unregister_supply_alias(dev, id[i]);
522
523         return ret;
524 }
525 EXPORT_SYMBOL_GPL(devm_regulator_bulk_register_supply_alias);
526
527 struct regulator_notifier_match {
528         struct regulator *regulator;
529         struct notifier_block *nb;
530 };
531
532 static int devm_regulator_match_notifier(struct device *dev, void *res,
533                                          void *data)
534 {
535         struct regulator_notifier_match *match = res;
536         struct regulator_notifier_match *target = data;
537
538         return match->regulator == target->regulator && match->nb == target->nb;
539 }
540
541 static void devm_regulator_destroy_notifier(struct device *dev, void *res)
542 {
543         struct regulator_notifier_match *match = res;
544
545         regulator_unregister_notifier(match->regulator, match->nb);
546 }
547
548 /**
549  * devm_regulator_register_notifier - Resource managed
550  * regulator_register_notifier
551  *
552  * @regulator: regulator source
553  * @nb:        notifier block
554  *
555  * The notifier will be registers under the consumer device and be
556  * automatically be unregistered when the source device is unbound.
557  */
558 int devm_regulator_register_notifier(struct regulator *regulator,
559                                      struct notifier_block *nb)
560 {
561         struct regulator_notifier_match *match;
562         int ret;
563
564         match = devres_alloc(devm_regulator_destroy_notifier,
565                              sizeof(struct regulator_notifier_match),
566                              GFP_KERNEL);
567         if (!match)
568                 return -ENOMEM;
569
570         match->regulator = regulator;
571         match->nb = nb;
572
573         ret = regulator_register_notifier(regulator, nb);
574         if (ret < 0) {
575                 devres_free(match);
576                 return ret;
577         }
578
579         devres_add(regulator->dev, match);
580
581         return 0;
582 }
583 EXPORT_SYMBOL_GPL(devm_regulator_register_notifier);
584
585 /**
586  * devm_regulator_unregister_notifier - Resource managed
587  * regulator_unregister_notifier()
588  *
589  * @regulator: regulator source
590  * @nb:        notifier block
591  *
592  * Unregister a notifier registered with devm_regulator_register_notifier().
593  * Normally this function will not need to be called and the resource
594  * management code will ensure that the resource is freed.
595  */
596 void devm_regulator_unregister_notifier(struct regulator *regulator,
597                                         struct notifier_block *nb)
598 {
599         struct regulator_notifier_match match;
600         int rc;
601
602         match.regulator = regulator;
603         match.nb = nb;
604
605         rc = devres_release(regulator->dev, devm_regulator_destroy_notifier,
606                             devm_regulator_match_notifier, &match);
607         if (rc != 0)
608                 WARN_ON(rc);
609 }
610 EXPORT_SYMBOL_GPL(devm_regulator_unregister_notifier);
611
612 static void regulator_irq_helper_drop(void *res)
613 {
614         regulator_irq_helper_cancel(&res);
615 }
616
617 /**
618  * devm_regulator_irq_helper - resource managed registration of IRQ based
619  * regulator event/error notifier
620  *
621  * @dev:                device to which lifetime the helper's lifetime is
622  *                      bound.
623  * @d:                  IRQ helper descriptor.
624  * @irq:                IRQ used to inform events/errors to be notified.
625  * @irq_flags:          Extra IRQ flags to be OR'ed with the default
626  *                      IRQF_ONESHOT when requesting the (threaded) irq.
627  * @common_errs:        Errors which can be flagged by this IRQ for all rdevs.
628  *                      When IRQ is re-enabled these errors will be cleared
629  *                      from all associated regulators
630  * @per_rdev_errs:      Optional error flag array describing errors specific
631  *                      for only some of the regulators. These errors will be
632  *                      or'ed with common errors. If this is given the array
633  *                      should contain rdev_amount flags. Can be set to NULL
634  *                      if there is no regulator specific error flags for this
635  *                      IRQ.
636  * @rdev:               Array of pointers to regulators associated with this
637  *                      IRQ.
638  * @rdev_amount:        Amount of regulators associated with this IRQ.
639  *
640  * Return: handle to irq_helper or an ERR_PTR() encoded error code.
641  */
642 void *devm_regulator_irq_helper(struct device *dev,
643                                 const struct regulator_irq_desc *d, int irq,
644                                 int irq_flags, int common_errs,
645                                 int *per_rdev_errs,
646                                 struct regulator_dev **rdev, int rdev_amount)
647 {
648         void *ptr;
649         int ret;
650
651         ptr = regulator_irq_helper(dev, d, irq, irq_flags, common_errs,
652                                     per_rdev_errs, rdev, rdev_amount);
653         if (IS_ERR(ptr))
654                 return ptr;
655
656         ret = devm_add_action_or_reset(dev, regulator_irq_helper_drop, ptr);
657         if (ret)
658                 return ERR_PTR(ret);
659
660         return ptr;
661 }
662 EXPORT_SYMBOL_GPL(devm_regulator_irq_helper);