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