Merge tag 'for-v4.8' of git://git.kernel.org/pub/scm/linux/kernel/git/sre/linux-power...
[sfrench/cifs-2.6.git] / drivers / power / power_supply_core.c
1 /*
2  *  Universal power supply monitor class
3  *
4  *  Copyright © 2007  Anton Vorontsov <cbou@mail.ru>
5  *  Copyright © 2004  Szabolcs Gyurko
6  *  Copyright © 2003  Ian Molton <spyro@f2s.com>
7  *
8  *  Modified: 2004, Oct     Szabolcs Gyurko
9  *
10  *  You may use this code as per GPL version 2
11  */
12
13 #include <linux/module.h>
14 #include <linux/types.h>
15 #include <linux/init.h>
16 #include <linux/slab.h>
17 #include <linux/device.h>
18 #include <linux/notifier.h>
19 #include <linux/err.h>
20 #include <linux/power_supply.h>
21 #include <linux/thermal.h>
22 #include "power_supply.h"
23
24 /* exported for the APM Power driver, APM emulation */
25 struct class *power_supply_class;
26 EXPORT_SYMBOL_GPL(power_supply_class);
27
28 ATOMIC_NOTIFIER_HEAD(power_supply_notifier);
29 EXPORT_SYMBOL_GPL(power_supply_notifier);
30
31 static struct device_type power_supply_dev_type;
32
33 #define POWER_SUPPLY_DEFERRED_REGISTER_TIME     msecs_to_jiffies(10)
34
35 static bool __power_supply_is_supplied_by(struct power_supply *supplier,
36                                          struct power_supply *supply)
37 {
38         int i;
39
40         if (!supply->supplied_from && !supplier->supplied_to)
41                 return false;
42
43         /* Support both supplied_to and supplied_from modes */
44         if (supply->supplied_from) {
45                 if (!supplier->desc->name)
46                         return false;
47                 for (i = 0; i < supply->num_supplies; i++)
48                         if (!strcmp(supplier->desc->name, supply->supplied_from[i]))
49                                 return true;
50         } else {
51                 if (!supply->desc->name)
52                         return false;
53                 for (i = 0; i < supplier->num_supplicants; i++)
54                         if (!strcmp(supplier->supplied_to[i], supply->desc->name))
55                                 return true;
56         }
57
58         return false;
59 }
60
61 static int __power_supply_changed_work(struct device *dev, void *data)
62 {
63         struct power_supply *psy = data;
64         struct power_supply *pst = dev_get_drvdata(dev);
65
66         if (__power_supply_is_supplied_by(psy, pst)) {
67                 if (pst->desc->external_power_changed)
68                         pst->desc->external_power_changed(pst);
69         }
70
71         return 0;
72 }
73
74 static void power_supply_changed_work(struct work_struct *work)
75 {
76         unsigned long flags;
77         struct power_supply *psy = container_of(work, struct power_supply,
78                                                 changed_work);
79
80         dev_dbg(&psy->dev, "%s\n", __func__);
81
82         spin_lock_irqsave(&psy->changed_lock, flags);
83         /*
84          * Check 'changed' here to avoid issues due to race between
85          * power_supply_changed() and this routine. In worst case
86          * power_supply_changed() can be called again just before we take above
87          * lock. During the first call of this routine we will mark 'changed' as
88          * false and it will stay false for the next call as well.
89          */
90         if (likely(psy->changed)) {
91                 psy->changed = false;
92                 spin_unlock_irqrestore(&psy->changed_lock, flags);
93                 class_for_each_device(power_supply_class, NULL, psy,
94                                       __power_supply_changed_work);
95                 power_supply_update_leds(psy);
96                 atomic_notifier_call_chain(&power_supply_notifier,
97                                 PSY_EVENT_PROP_CHANGED, psy);
98                 kobject_uevent(&psy->dev.kobj, KOBJ_CHANGE);
99                 spin_lock_irqsave(&psy->changed_lock, flags);
100         }
101
102         /*
103          * Hold the wakeup_source until all events are processed.
104          * power_supply_changed() might have called again and have set 'changed'
105          * to true.
106          */
107         if (likely(!psy->changed))
108                 pm_relax(&psy->dev);
109         spin_unlock_irqrestore(&psy->changed_lock, flags);
110 }
111
112 void power_supply_changed(struct power_supply *psy)
113 {
114         unsigned long flags;
115
116         dev_dbg(&psy->dev, "%s\n", __func__);
117
118         spin_lock_irqsave(&psy->changed_lock, flags);
119         psy->changed = true;
120         pm_stay_awake(&psy->dev);
121         spin_unlock_irqrestore(&psy->changed_lock, flags);
122         schedule_work(&psy->changed_work);
123 }
124 EXPORT_SYMBOL_GPL(power_supply_changed);
125
126 /*
127  * Notify that power supply was registered after parent finished the probing.
128  *
129  * Often power supply is registered from driver's probe function. However
130  * calling power_supply_changed() directly from power_supply_register()
131  * would lead to execution of get_property() function provided by the driver
132  * too early - before the probe ends.
133  *
134  * Avoid that by waiting on parent's mutex.
135  */
136 static void power_supply_deferred_register_work(struct work_struct *work)
137 {
138         struct power_supply *psy = container_of(work, struct power_supply,
139                                                 deferred_register_work.work);
140
141         if (psy->dev.parent)
142                 mutex_lock(&psy->dev.parent->mutex);
143
144         power_supply_changed(psy);
145
146         if (psy->dev.parent)
147                 mutex_unlock(&psy->dev.parent->mutex);
148 }
149
150 #ifdef CONFIG_OF
151 #include <linux/of.h>
152
153 static int __power_supply_populate_supplied_from(struct device *dev,
154                                                  void *data)
155 {
156         struct power_supply *psy = data;
157         struct power_supply *epsy = dev_get_drvdata(dev);
158         struct device_node *np;
159         int i = 0;
160
161         do {
162                 np = of_parse_phandle(psy->of_node, "power-supplies", i++);
163                 if (!np)
164                         break;
165
166                 if (np == epsy->of_node) {
167                         dev_info(&psy->dev, "%s: Found supply : %s\n",
168                                 psy->desc->name, epsy->desc->name);
169                         psy->supplied_from[i-1] = (char *)epsy->desc->name;
170                         psy->num_supplies++;
171                         of_node_put(np);
172                         break;
173                 }
174                 of_node_put(np);
175         } while (np);
176
177         return 0;
178 }
179
180 static int power_supply_populate_supplied_from(struct power_supply *psy)
181 {
182         int error;
183
184         error = class_for_each_device(power_supply_class, NULL, psy,
185                                       __power_supply_populate_supplied_from);
186
187         dev_dbg(&psy->dev, "%s %d\n", __func__, error);
188
189         return error;
190 }
191
192 static int  __power_supply_find_supply_from_node(struct device *dev,
193                                                  void *data)
194 {
195         struct device_node *np = data;
196         struct power_supply *epsy = dev_get_drvdata(dev);
197
198         /* returning non-zero breaks out of class_for_each_device loop */
199         if (epsy->of_node == np)
200                 return 1;
201
202         return 0;
203 }
204
205 static int power_supply_find_supply_from_node(struct device_node *supply_node)
206 {
207         int error;
208
209         /*
210          * class_for_each_device() either returns its own errors or values
211          * returned by __power_supply_find_supply_from_node().
212          *
213          * __power_supply_find_supply_from_node() will return 0 (no match)
214          * or 1 (match).
215          *
216          * We return 0 if class_for_each_device() returned 1, -EPROBE_DEFER if
217          * it returned 0, or error as returned by it.
218          */
219         error = class_for_each_device(power_supply_class, NULL, supply_node,
220                                        __power_supply_find_supply_from_node);
221
222         return error ? (error == 1 ? 0 : error) : -EPROBE_DEFER;
223 }
224
225 static int power_supply_check_supplies(struct power_supply *psy)
226 {
227         struct device_node *np;
228         int cnt = 0;
229
230         /* If there is already a list honor it */
231         if (psy->supplied_from && psy->num_supplies > 0)
232                 return 0;
233
234         /* No device node found, nothing to do */
235         if (!psy->of_node)
236                 return 0;
237
238         do {
239                 int ret;
240
241                 np = of_parse_phandle(psy->of_node, "power-supplies", cnt++);
242                 if (!np)
243                         break;
244
245                 ret = power_supply_find_supply_from_node(np);
246                 of_node_put(np);
247
248                 if (ret) {
249                         dev_dbg(&psy->dev, "Failed to find supply!\n");
250                         return ret;
251                 }
252         } while (np);
253
254         /* Missing valid "power-supplies" entries */
255         if (cnt == 1)
256                 return 0;
257
258         /* All supplies found, allocate char ** array for filling */
259         psy->supplied_from = devm_kzalloc(&psy->dev, sizeof(psy->supplied_from),
260                                           GFP_KERNEL);
261         if (!psy->supplied_from) {
262                 dev_err(&psy->dev, "Couldn't allocate memory for supply list\n");
263                 return -ENOMEM;
264         }
265
266         *psy->supplied_from = devm_kzalloc(&psy->dev,
267                                            sizeof(char *) * (cnt - 1),
268                                            GFP_KERNEL);
269         if (!*psy->supplied_from) {
270                 dev_err(&psy->dev, "Couldn't allocate memory for supply list\n");
271                 return -ENOMEM;
272         }
273
274         return power_supply_populate_supplied_from(psy);
275 }
276 #else
277 static inline int power_supply_check_supplies(struct power_supply *psy)
278 {
279         return 0;
280 }
281 #endif
282
283 static int __power_supply_am_i_supplied(struct device *dev, void *data)
284 {
285         union power_supply_propval ret = {0,};
286         struct power_supply *psy = data;
287         struct power_supply *epsy = dev_get_drvdata(dev);
288
289         if (__power_supply_is_supplied_by(epsy, psy))
290                 if (!epsy->desc->get_property(epsy, POWER_SUPPLY_PROP_ONLINE,
291                                         &ret))
292                         return ret.intval;
293
294         return 0;
295 }
296
297 int power_supply_am_i_supplied(struct power_supply *psy)
298 {
299         int error;
300
301         error = class_for_each_device(power_supply_class, NULL, psy,
302                                       __power_supply_am_i_supplied);
303
304         dev_dbg(&psy->dev, "%s %d\n", __func__, error);
305
306         return error;
307 }
308 EXPORT_SYMBOL_GPL(power_supply_am_i_supplied);
309
310 static int __power_supply_is_system_supplied(struct device *dev, void *data)
311 {
312         union power_supply_propval ret = {0,};
313         struct power_supply *psy = dev_get_drvdata(dev);
314         unsigned int *count = data;
315
316         (*count)++;
317         if (psy->desc->type != POWER_SUPPLY_TYPE_BATTERY)
318                 if (!psy->desc->get_property(psy, POWER_SUPPLY_PROP_ONLINE,
319                                         &ret))
320                         return ret.intval;
321
322         return 0;
323 }
324
325 int power_supply_is_system_supplied(void)
326 {
327         int error;
328         unsigned int count = 0;
329
330         error = class_for_each_device(power_supply_class, NULL, &count,
331                                       __power_supply_is_system_supplied);
332
333         /*
334          * If no power class device was found at all, most probably we are
335          * running on a desktop system, so assume we are on mains power.
336          */
337         if (count == 0)
338                 return 1;
339
340         return error;
341 }
342 EXPORT_SYMBOL_GPL(power_supply_is_system_supplied);
343
344 int power_supply_set_battery_charged(struct power_supply *psy)
345 {
346         if (atomic_read(&psy->use_cnt) >= 0 &&
347                         psy->desc->type == POWER_SUPPLY_TYPE_BATTERY &&
348                         psy->desc->set_charged) {
349                 psy->desc->set_charged(psy);
350                 return 0;
351         }
352
353         return -EINVAL;
354 }
355 EXPORT_SYMBOL_GPL(power_supply_set_battery_charged);
356
357 static int power_supply_match_device_by_name(struct device *dev, const void *data)
358 {
359         const char *name = data;
360         struct power_supply *psy = dev_get_drvdata(dev);
361
362         return strcmp(psy->desc->name, name) == 0;
363 }
364
365 /**
366  * power_supply_get_by_name() - Search for a power supply and returns its ref
367  * @name: Power supply name to fetch
368  *
369  * If power supply was found, it increases reference count for the
370  * internal power supply's device. The user should power_supply_put()
371  * after usage.
372  *
373  * Return: On success returns a reference to a power supply with
374  * matching name equals to @name, a NULL otherwise.
375  */
376 struct power_supply *power_supply_get_by_name(const char *name)
377 {
378         struct power_supply *psy = NULL;
379         struct device *dev = class_find_device(power_supply_class, NULL, name,
380                                         power_supply_match_device_by_name);
381
382         if (dev) {
383                 psy = dev_get_drvdata(dev);
384                 atomic_inc(&psy->use_cnt);
385         }
386
387         return psy;
388 }
389 EXPORT_SYMBOL_GPL(power_supply_get_by_name);
390
391 /**
392  * power_supply_put() - Drop reference obtained with power_supply_get_by_name
393  * @psy: Reference to put
394  *
395  * The reference to power supply should be put before unregistering
396  * the power supply.
397  */
398 void power_supply_put(struct power_supply *psy)
399 {
400         might_sleep();
401
402         atomic_dec(&psy->use_cnt);
403         put_device(&psy->dev);
404 }
405 EXPORT_SYMBOL_GPL(power_supply_put);
406
407 #ifdef CONFIG_OF
408 static int power_supply_match_device_node(struct device *dev, const void *data)
409 {
410         return dev->parent && dev->parent->of_node == data;
411 }
412
413 /**
414  * power_supply_get_by_phandle() - Search for a power supply and returns its ref
415  * @np: Pointer to device node holding phandle property
416  * @phandle_name: Name of property holding a power supply name
417  *
418  * If power supply was found, it increases reference count for the
419  * internal power supply's device. The user should power_supply_put()
420  * after usage.
421  *
422  * Return: On success returns a reference to a power supply with
423  * matching name equals to value under @property, NULL or ERR_PTR otherwise.
424  */
425 struct power_supply *power_supply_get_by_phandle(struct device_node *np,
426                                                         const char *property)
427 {
428         struct device_node *power_supply_np;
429         struct power_supply *psy = NULL;
430         struct device *dev;
431
432         power_supply_np = of_parse_phandle(np, property, 0);
433         if (!power_supply_np)
434                 return ERR_PTR(-ENODEV);
435
436         dev = class_find_device(power_supply_class, NULL, power_supply_np,
437                                                 power_supply_match_device_node);
438
439         of_node_put(power_supply_np);
440
441         if (dev) {
442                 psy = dev_get_drvdata(dev);
443                 atomic_inc(&psy->use_cnt);
444         }
445
446         return psy;
447 }
448 EXPORT_SYMBOL_GPL(power_supply_get_by_phandle);
449
450 static void devm_power_supply_put(struct device *dev, void *res)
451 {
452         struct power_supply **psy = res;
453
454         power_supply_put(*psy);
455 }
456
457 /**
458  * devm_power_supply_get_by_phandle() - Resource managed version of
459  *  power_supply_get_by_phandle()
460  * @dev: Pointer to device holding phandle property
461  * @phandle_name: Name of property holding a power supply phandle
462  *
463  * Return: On success returns a reference to a power supply with
464  * matching name equals to value under @property, NULL or ERR_PTR otherwise.
465  */
466 struct power_supply *devm_power_supply_get_by_phandle(struct device *dev,
467                                                       const char *property)
468 {
469         struct power_supply **ptr, *psy;
470
471         if (!dev->of_node)
472                 return ERR_PTR(-ENODEV);
473
474         ptr = devres_alloc(devm_power_supply_put, sizeof(*ptr), GFP_KERNEL);
475         if (!ptr)
476                 return ERR_PTR(-ENOMEM);
477
478         psy = power_supply_get_by_phandle(dev->of_node, property);
479         if (IS_ERR_OR_NULL(psy)) {
480                 devres_free(ptr);
481         } else {
482                 *ptr = psy;
483                 devres_add(dev, ptr);
484         }
485         return psy;
486 }
487 EXPORT_SYMBOL_GPL(devm_power_supply_get_by_phandle);
488 #endif /* CONFIG_OF */
489
490 int power_supply_get_property(struct power_supply *psy,
491                             enum power_supply_property psp,
492                             union power_supply_propval *val)
493 {
494         if (atomic_read(&psy->use_cnt) <= 0) {
495                 if (!psy->initialized)
496                         return -EAGAIN;
497                 return -ENODEV;
498         }
499
500         return psy->desc->get_property(psy, psp, val);
501 }
502 EXPORT_SYMBOL_GPL(power_supply_get_property);
503
504 int power_supply_set_property(struct power_supply *psy,
505                             enum power_supply_property psp,
506                             const union power_supply_propval *val)
507 {
508         if (atomic_read(&psy->use_cnt) <= 0 || !psy->desc->set_property)
509                 return -ENODEV;
510
511         return psy->desc->set_property(psy, psp, val);
512 }
513 EXPORT_SYMBOL_GPL(power_supply_set_property);
514
515 int power_supply_property_is_writeable(struct power_supply *psy,
516                                         enum power_supply_property psp)
517 {
518         if (atomic_read(&psy->use_cnt) <= 0 ||
519                         !psy->desc->property_is_writeable)
520                 return -ENODEV;
521
522         return psy->desc->property_is_writeable(psy, psp);
523 }
524 EXPORT_SYMBOL_GPL(power_supply_property_is_writeable);
525
526 void power_supply_external_power_changed(struct power_supply *psy)
527 {
528         if (atomic_read(&psy->use_cnt) <= 0 ||
529                         !psy->desc->external_power_changed)
530                 return;
531
532         psy->desc->external_power_changed(psy);
533 }
534 EXPORT_SYMBOL_GPL(power_supply_external_power_changed);
535
536 int power_supply_powers(struct power_supply *psy, struct device *dev)
537 {
538         return sysfs_create_link(&psy->dev.kobj, &dev->kobj, "powers");
539 }
540 EXPORT_SYMBOL_GPL(power_supply_powers);
541
542 static void power_supply_dev_release(struct device *dev)
543 {
544         struct power_supply *psy = container_of(dev, struct power_supply, dev);
545         pr_debug("device: '%s': %s\n", dev_name(dev), __func__);
546         kfree(psy);
547 }
548
549 int power_supply_reg_notifier(struct notifier_block *nb)
550 {
551         return atomic_notifier_chain_register(&power_supply_notifier, nb);
552 }
553 EXPORT_SYMBOL_GPL(power_supply_reg_notifier);
554
555 void power_supply_unreg_notifier(struct notifier_block *nb)
556 {
557         atomic_notifier_chain_unregister(&power_supply_notifier, nb);
558 }
559 EXPORT_SYMBOL_GPL(power_supply_unreg_notifier);
560
561 #ifdef CONFIG_THERMAL
562 static int power_supply_read_temp(struct thermal_zone_device *tzd,
563                 int *temp)
564 {
565         struct power_supply *psy;
566         union power_supply_propval val;
567         int ret;
568
569         WARN_ON(tzd == NULL);
570         psy = tzd->devdata;
571         ret = power_supply_get_property(psy, POWER_SUPPLY_PROP_TEMP, &val);
572         if (ret)
573                 return ret;
574
575         /* Convert tenths of degree Celsius to milli degree Celsius. */
576         *temp = val.intval * 100;
577
578         return ret;
579 }
580
581 static struct thermal_zone_device_ops psy_tzd_ops = {
582         .get_temp = power_supply_read_temp,
583 };
584
585 static int psy_register_thermal(struct power_supply *psy)
586 {
587         int i;
588
589         if (psy->desc->no_thermal)
590                 return 0;
591
592         /* Register battery zone device psy reports temperature */
593         for (i = 0; i < psy->desc->num_properties; i++) {
594                 if (psy->desc->properties[i] == POWER_SUPPLY_PROP_TEMP) {
595                         psy->tzd = thermal_zone_device_register(psy->desc->name,
596                                         0, 0, psy, &psy_tzd_ops, NULL, 0, 0);
597                         return PTR_ERR_OR_ZERO(psy->tzd);
598                 }
599         }
600         return 0;
601 }
602
603 static void psy_unregister_thermal(struct power_supply *psy)
604 {
605         if (IS_ERR_OR_NULL(psy->tzd))
606                 return;
607         thermal_zone_device_unregister(psy->tzd);
608 }
609
610 /* thermal cooling device callbacks */
611 static int ps_get_max_charge_cntl_limit(struct thermal_cooling_device *tcd,
612                                         unsigned long *state)
613 {
614         struct power_supply *psy;
615         union power_supply_propval val;
616         int ret;
617
618         psy = tcd->devdata;
619         ret = power_supply_get_property(psy,
620                         POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT_MAX, &val);
621         if (ret)
622                 return ret;
623
624         *state = val.intval;
625
626         return ret;
627 }
628
629 static int ps_get_cur_chrage_cntl_limit(struct thermal_cooling_device *tcd,
630                                         unsigned long *state)
631 {
632         struct power_supply *psy;
633         union power_supply_propval val;
634         int ret;
635
636         psy = tcd->devdata;
637         ret = power_supply_get_property(psy,
638                         POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT, &val);
639         if (ret)
640                 return ret;
641
642         *state = val.intval;
643
644         return ret;
645 }
646
647 static int ps_set_cur_charge_cntl_limit(struct thermal_cooling_device *tcd,
648                                         unsigned long state)
649 {
650         struct power_supply *psy;
651         union power_supply_propval val;
652         int ret;
653
654         psy = tcd->devdata;
655         val.intval = state;
656         ret = psy->desc->set_property(psy,
657                 POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT, &val);
658
659         return ret;
660 }
661
662 static struct thermal_cooling_device_ops psy_tcd_ops = {
663         .get_max_state = ps_get_max_charge_cntl_limit,
664         .get_cur_state = ps_get_cur_chrage_cntl_limit,
665         .set_cur_state = ps_set_cur_charge_cntl_limit,
666 };
667
668 static int psy_register_cooler(struct power_supply *psy)
669 {
670         int i;
671
672         /* Register for cooling device if psy can control charging */
673         for (i = 0; i < psy->desc->num_properties; i++) {
674                 if (psy->desc->properties[i] ==
675                                 POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT) {
676                         psy->tcd = thermal_cooling_device_register(
677                                                         (char *)psy->desc->name,
678                                                         psy, &psy_tcd_ops);
679                         return PTR_ERR_OR_ZERO(psy->tcd);
680                 }
681         }
682         return 0;
683 }
684
685 static void psy_unregister_cooler(struct power_supply *psy)
686 {
687         if (IS_ERR_OR_NULL(psy->tcd))
688                 return;
689         thermal_cooling_device_unregister(psy->tcd);
690 }
691 #else
692 static int psy_register_thermal(struct power_supply *psy)
693 {
694         return 0;
695 }
696
697 static void psy_unregister_thermal(struct power_supply *psy)
698 {
699 }
700
701 static int psy_register_cooler(struct power_supply *psy)
702 {
703         return 0;
704 }
705
706 static void psy_unregister_cooler(struct power_supply *psy)
707 {
708 }
709 #endif
710
711 static struct power_supply *__must_check
712 __power_supply_register(struct device *parent,
713                                    const struct power_supply_desc *desc,
714                                    const struct power_supply_config *cfg,
715                                    bool ws)
716 {
717         struct device *dev;
718         struct power_supply *psy;
719         int rc;
720
721         if (!parent)
722                 pr_warn("%s: Expected proper parent device for '%s'\n",
723                         __func__, desc->name);
724
725         psy = kzalloc(sizeof(*psy), GFP_KERNEL);
726         if (!psy)
727                 return ERR_PTR(-ENOMEM);
728
729         dev = &psy->dev;
730
731         device_initialize(dev);
732
733         dev->class = power_supply_class;
734         dev->type = &power_supply_dev_type;
735         dev->parent = parent;
736         dev->release = power_supply_dev_release;
737         dev_set_drvdata(dev, psy);
738         psy->desc = desc;
739         if (cfg) {
740                 psy->drv_data = cfg->drv_data;
741                 psy->of_node = cfg->of_node;
742                 psy->supplied_to = cfg->supplied_to;
743                 psy->num_supplicants = cfg->num_supplicants;
744         }
745
746         rc = dev_set_name(dev, "%s", desc->name);
747         if (rc)
748                 goto dev_set_name_failed;
749
750         INIT_WORK(&psy->changed_work, power_supply_changed_work);
751         INIT_DELAYED_WORK(&psy->deferred_register_work,
752                           power_supply_deferred_register_work);
753
754         rc = power_supply_check_supplies(psy);
755         if (rc) {
756                 dev_info(dev, "Not all required supplies found, defer probe\n");
757                 goto check_supplies_failed;
758         }
759
760         spin_lock_init(&psy->changed_lock);
761         rc = device_init_wakeup(dev, ws);
762         if (rc)
763                 goto wakeup_init_failed;
764
765         rc = device_add(dev);
766         if (rc)
767                 goto device_add_failed;
768
769         rc = psy_register_thermal(psy);
770         if (rc)
771                 goto register_thermal_failed;
772
773         rc = psy_register_cooler(psy);
774         if (rc)
775                 goto register_cooler_failed;
776
777         rc = power_supply_create_triggers(psy);
778         if (rc)
779                 goto create_triggers_failed;
780
781         /*
782          * Update use_cnt after any uevents (most notably from device_add()).
783          * We are here still during driver's probe but
784          * the power_supply_uevent() calls back driver's get_property
785          * method so:
786          * 1. Driver did not assigned the returned struct power_supply,
787          * 2. Driver could not finish initialization (anything in its probe
788          *    after calling power_supply_register()).
789          */
790         atomic_inc(&psy->use_cnt);
791         psy->initialized = true;
792
793         queue_delayed_work(system_power_efficient_wq,
794                            &psy->deferred_register_work,
795                            POWER_SUPPLY_DEFERRED_REGISTER_TIME);
796
797         return psy;
798
799 create_triggers_failed:
800         psy_unregister_cooler(psy);
801 register_cooler_failed:
802         psy_unregister_thermal(psy);
803 register_thermal_failed:
804         device_del(dev);
805 device_add_failed:
806 wakeup_init_failed:
807 check_supplies_failed:
808 dev_set_name_failed:
809         put_device(dev);
810         return ERR_PTR(rc);
811 }
812
813 /**
814  * power_supply_register() - Register new power supply
815  * @parent:     Device to be a parent of power supply's device, usually
816  *              the device which probe function calls this
817  * @desc:       Description of power supply, must be valid through whole
818  *              lifetime of this power supply
819  * @cfg:        Run-time specific configuration accessed during registering,
820  *              may be NULL
821  *
822  * Return: A pointer to newly allocated power_supply on success
823  * or ERR_PTR otherwise.
824  * Use power_supply_unregister() on returned power_supply pointer to release
825  * resources.
826  */
827 struct power_supply *__must_check power_supply_register(struct device *parent,
828                 const struct power_supply_desc *desc,
829                 const struct power_supply_config *cfg)
830 {
831         return __power_supply_register(parent, desc, cfg, true);
832 }
833 EXPORT_SYMBOL_GPL(power_supply_register);
834
835 /**
836  * power_supply_register_no_ws() - Register new non-waking-source power supply
837  * @parent:     Device to be a parent of power supply's device, usually
838  *              the device which probe function calls this
839  * @desc:       Description of power supply, must be valid through whole
840  *              lifetime of this power supply
841  * @cfg:        Run-time specific configuration accessed during registering,
842  *              may be NULL
843  *
844  * Return: A pointer to newly allocated power_supply on success
845  * or ERR_PTR otherwise.
846  * Use power_supply_unregister() on returned power_supply pointer to release
847  * resources.
848  */
849 struct power_supply *__must_check
850 power_supply_register_no_ws(struct device *parent,
851                 const struct power_supply_desc *desc,
852                 const struct power_supply_config *cfg)
853 {
854         return __power_supply_register(parent, desc, cfg, false);
855 }
856 EXPORT_SYMBOL_GPL(power_supply_register_no_ws);
857
858 static void devm_power_supply_release(struct device *dev, void *res)
859 {
860         struct power_supply **psy = res;
861
862         power_supply_unregister(*psy);
863 }
864
865 /**
866  * devm_power_supply_register() - Register managed power supply
867  * @parent:     Device to be a parent of power supply's device, usually
868  *              the device which probe function calls this
869  * @desc:       Description of power supply, must be valid through whole
870  *              lifetime of this power supply
871  * @cfg:        Run-time specific configuration accessed during registering,
872  *              may be NULL
873  *
874  * Return: A pointer to newly allocated power_supply on success
875  * or ERR_PTR otherwise.
876  * The returned power_supply pointer will be automatically unregistered
877  * on driver detach.
878  */
879 struct power_supply *__must_check
880 devm_power_supply_register(struct device *parent,
881                 const struct power_supply_desc *desc,
882                 const struct power_supply_config *cfg)
883 {
884         struct power_supply **ptr, *psy;
885
886         ptr = devres_alloc(devm_power_supply_release, sizeof(*ptr), GFP_KERNEL);
887
888         if (!ptr)
889                 return ERR_PTR(-ENOMEM);
890         psy = __power_supply_register(parent, desc, cfg, true);
891         if (IS_ERR(psy)) {
892                 devres_free(ptr);
893         } else {
894                 *ptr = psy;
895                 devres_add(parent, ptr);
896         }
897         return psy;
898 }
899 EXPORT_SYMBOL_GPL(devm_power_supply_register);
900
901 /**
902  * devm_power_supply_register_no_ws() - Register managed non-waking-source power supply
903  * @parent:     Device to be a parent of power supply's device, usually
904  *              the device which probe function calls this
905  * @desc:       Description of power supply, must be valid through whole
906  *              lifetime of this power supply
907  * @cfg:        Run-time specific configuration accessed during registering,
908  *              may be NULL
909  *
910  * Return: A pointer to newly allocated power_supply on success
911  * or ERR_PTR otherwise.
912  * The returned power_supply pointer will be automatically unregistered
913  * on driver detach.
914  */
915 struct power_supply *__must_check
916 devm_power_supply_register_no_ws(struct device *parent,
917                 const struct power_supply_desc *desc,
918                 const struct power_supply_config *cfg)
919 {
920         struct power_supply **ptr, *psy;
921
922         ptr = devres_alloc(devm_power_supply_release, sizeof(*ptr), GFP_KERNEL);
923
924         if (!ptr)
925                 return ERR_PTR(-ENOMEM);
926         psy = __power_supply_register(parent, desc, cfg, false);
927         if (IS_ERR(psy)) {
928                 devres_free(ptr);
929         } else {
930                 *ptr = psy;
931                 devres_add(parent, ptr);
932         }
933         return psy;
934 }
935 EXPORT_SYMBOL_GPL(devm_power_supply_register_no_ws);
936
937 /**
938  * power_supply_unregister() - Remove this power supply from system
939  * @psy:        Pointer to power supply to unregister
940  *
941  * Remove this power supply from the system. The resources of power supply
942  * will be freed here or on last power_supply_put() call.
943  */
944 void power_supply_unregister(struct power_supply *psy)
945 {
946         WARN_ON(atomic_dec_return(&psy->use_cnt));
947         cancel_work_sync(&psy->changed_work);
948         cancel_delayed_work_sync(&psy->deferred_register_work);
949         sysfs_remove_link(&psy->dev.kobj, "powers");
950         power_supply_remove_triggers(psy);
951         psy_unregister_cooler(psy);
952         psy_unregister_thermal(psy);
953         device_init_wakeup(&psy->dev, false);
954         device_unregister(&psy->dev);
955 }
956 EXPORT_SYMBOL_GPL(power_supply_unregister);
957
958 void *power_supply_get_drvdata(struct power_supply *psy)
959 {
960         return psy->drv_data;
961 }
962 EXPORT_SYMBOL_GPL(power_supply_get_drvdata);
963
964 static int __init power_supply_class_init(void)
965 {
966         power_supply_class = class_create(THIS_MODULE, "power_supply");
967
968         if (IS_ERR(power_supply_class))
969                 return PTR_ERR(power_supply_class);
970
971         power_supply_class->dev_uevent = power_supply_uevent;
972         power_supply_init_attrs(&power_supply_dev_type);
973
974         return 0;
975 }
976
977 static void __exit power_supply_class_exit(void)
978 {
979         class_destroy(power_supply_class);
980 }
981
982 subsys_initcall(power_supply_class_init);
983 module_exit(power_supply_class_exit);
984
985 MODULE_DESCRIPTION("Universal power supply monitor class");
986 MODULE_AUTHOR("Ian Molton <spyro@f2s.com>, "
987               "Szabolcs Gyurko, "
988               "Anton Vorontsov <cbou@mail.ru>");
989 MODULE_LICENSE("GPL");