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");
990