Merge branch 'next' into for-linus
[linux-2.6-microblaze.git] / 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);