1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * Universal power supply monitor class
4 *
5 * Copyright © 2007 Anton Vorontsov <cbou@mail.ru>
6 * Copyright © 2004 Szabolcs Gyurko
7 * Copyright © 2003 Ian Molton <spyro@f2s.com>
8 *
9 * Modified: 2004, Oct Szabolcs Gyurko
10 */
11
12#include <linux/cleanup.h>
13#include <linux/module.h>
14#include <linux/types.h>
15#include <linux/init.h>
16#include <linux/slab.h>
17#include <linux/delay.h>
18#include <linux/device.h>
19#include <linux/notifier.h>
20#include <linux/err.h>
21#include <linux/power_supply.h>
22#include <linux/property.h>
23#include <linux/thermal.h>
24#include <linux/fixp-arith.h>
25#include "power_supply.h"
26#include "samsung-sdi-battery.h"
27
28static const struct class power_supply_class = {
29 .name = "power_supply",
30 .dev_uevent = power_supply_uevent,
31};
32
33static BLOCKING_NOTIFIER_HEAD(power_supply_notifier);
34
35static const struct device_type power_supply_dev_type = {
36 .name = "power_supply",
37 .groups = power_supply_attr_groups,
38};
39
40#define POWER_SUPPLY_DEFERRED_REGISTER_TIME msecs_to_jiffies(10)
41
42static bool __power_supply_is_supplied_by(struct power_supply *supplier,
43 struct power_supply *supply)
44{
45 int i;
46
47 if (!supply->supplied_from && !supplier->supplied_to)
48 return false;
49
50 /* Support both supplied_to and supplied_from modes */
51 if (supply->supplied_from) {
52 if (!supplier->desc->name)
53 return false;
54 for (i = 0; i < supply->num_supplies; i++)
55 if (!strcmp(supplier->desc->name, supply->supplied_from[i]))
56 return true;
57 } else {
58 if (!supply->desc->name)
59 return false;
60 for (i = 0; i < supplier->num_supplicants; i++)
61 if (!strcmp(supplier->supplied_to[i], supply->desc->name))
62 return true;
63 }
64
65 return false;
66}
67
68static int __power_supply_changed_work(struct power_supply *pst, void *data)
69{
70 struct power_supply *psy = data;
71
72 if (__power_supply_is_supplied_by(supplier: psy, supply: pst))
73 power_supply_external_power_changed(psy: pst);
74
75 return 0;
76}
77
78static void power_supply_changed_work(struct work_struct *work)
79{
80 int ret;
81 unsigned long flags;
82 struct power_supply *psy = container_of(work, struct power_supply,
83 changed_work);
84
85 dev_dbg(&psy->dev, "%s\n", __func__);
86
87 spin_lock_irqsave(&psy->changed_lock, flags);
88
89 if (unlikely(psy->update_groups)) {
90 psy->update_groups = false;
91 spin_unlock_irqrestore(lock: &psy->changed_lock, flags);
92 ret = sysfs_update_groups(kobj: &psy->dev.kobj, groups: power_supply_dev_type.groups);
93 if (ret)
94 dev_warn(&psy->dev, "failed to update sysfs groups: %pe\n", ERR_PTR(ret));
95 spin_lock_irqsave(&psy->changed_lock, flags);
96 }
97
98 /*
99 * Check 'changed' here to avoid issues due to race between
100 * power_supply_changed() and this routine. In worst case
101 * power_supply_changed() can be called again just before we take above
102 * lock. During the first call of this routine we will mark 'changed' as
103 * false and it will stay false for the next call as well.
104 */
105 if (likely(psy->changed)) {
106 psy->changed = false;
107 spin_unlock_irqrestore(lock: &psy->changed_lock, flags);
108 power_supply_for_each_psy(data: psy, fn: __power_supply_changed_work);
109 power_supply_update_leds(psy);
110 blocking_notifier_call_chain(nh: &power_supply_notifier,
111 val: PSY_EVENT_PROP_CHANGED, v: psy);
112 kobject_uevent(kobj: &psy->dev.kobj, action: KOBJ_CHANGE);
113 spin_lock_irqsave(&psy->changed_lock, flags);
114 }
115
116 /*
117 * Hold the wakeup_source until all events are processed.
118 * power_supply_changed() might have called again and have set 'changed'
119 * to true.
120 */
121 if (likely(!psy->changed))
122 pm_relax(dev: &psy->dev);
123 spin_unlock_irqrestore(lock: &psy->changed_lock, flags);
124}
125
126struct psy_for_each_psy_cb_data {
127 int (*fn)(struct power_supply *psy, void *data);
128 void *data;
129};
130
131static int psy_for_each_psy_cb(struct device *dev, void *data)
132{
133 struct psy_for_each_psy_cb_data *cb_data = data;
134 struct power_supply *psy = dev_to_psy(dev);
135
136 return cb_data->fn(psy, cb_data->data);
137}
138
139int power_supply_for_each_psy(void *data, int (*fn)(struct power_supply *psy, void *data))
140{
141 struct psy_for_each_psy_cb_data cb_data = {
142 .fn = fn,
143 .data = data,
144 };
145
146 return class_for_each_device(class: &power_supply_class, NULL, data: &cb_data, fn: psy_for_each_psy_cb);
147}
148EXPORT_SYMBOL_GPL(power_supply_for_each_psy);
149
150void power_supply_changed(struct power_supply *psy)
151{
152 unsigned long flags;
153
154 dev_dbg(&psy->dev, "%s\n", __func__);
155
156 spin_lock_irqsave(&psy->changed_lock, flags);
157 psy->changed = true;
158 pm_stay_awake(dev: &psy->dev);
159 spin_unlock_irqrestore(lock: &psy->changed_lock, flags);
160 schedule_work(work: &psy->changed_work);
161}
162EXPORT_SYMBOL_GPL(power_supply_changed);
163
164/*
165 * Notify that power supply was registered after parent finished the probing.
166 *
167 * Often power supply is registered from driver's probe function. However
168 * calling power_supply_changed() directly from power_supply_register()
169 * would lead to execution of get_property() function provided by the driver
170 * too early - before the probe ends.
171 *
172 * Avoid that by waiting on parent's mutex.
173 */
174static void power_supply_deferred_register_work(struct work_struct *work)
175{
176 struct power_supply *psy = container_of(work, struct power_supply,
177 deferred_register_work.work);
178
179 if (psy->dev.parent) {
180 while (!device_trylock(dev: psy->dev.parent)) {
181 if (psy->removing)
182 return;
183 msleep(msecs: 10);
184 }
185 }
186
187 power_supply_changed(psy);
188
189 if (psy->dev.parent)
190 device_unlock(dev: psy->dev.parent);
191}
192
193#ifdef CONFIG_OF
194static int __power_supply_populate_supplied_from(struct power_supply *epsy,
195 void *data)
196{
197 struct power_supply *psy = data;
198 struct fwnode_handle *np;
199 int i = 0;
200
201 do {
202 np = fwnode_find_reference(psy->dev.fwnode, "power-supplies", i++);
203 if (IS_ERR(np))
204 break;
205
206 if (np == epsy->dev.fwnode) {
207 dev_dbg(&psy->dev, "%s: Found supply : %s\n",
208 psy->desc->name, epsy->desc->name);
209 psy->supplied_from[i-1] = (char *)epsy->desc->name;
210 psy->num_supplies++;
211 fwnode_handle_put(np);
212 break;
213 }
214 fwnode_handle_put(np);
215 } while (true);
216
217 return 0;
218}
219
220static int power_supply_populate_supplied_from(struct power_supply *psy)
221{
222 int error;
223
224 error = power_supply_for_each_psy(psy, __power_supply_populate_supplied_from);
225
226 dev_dbg(&psy->dev, "%s %d\n", __func__, error);
227
228 return error;
229}
230
231static int __power_supply_find_supply_from_node(struct power_supply *epsy,
232 void *data)
233{
234 struct fwnode_handle *fwnode = data;
235
236 /* returning non-zero breaks out of power_supply_for_each_psy loop */
237 if (epsy->dev.fwnode == fwnode)
238 return 1;
239
240 return 0;
241}
242
243static int power_supply_find_supply_from_fwnode(struct fwnode_handle *supply_node)
244{
245 int error;
246
247 /*
248 * power_supply_for_each_psy() either returns its own errors or values
249 * returned by __power_supply_find_supply_from_node().
250 *
251 * __power_supply_find_supply_from_fwnode() will return 0 (no match)
252 * or 1 (match).
253 *
254 * We return 0 if power_supply_for_each_psy() returned 1, -EPROBE_DEFER if
255 * it returned 0, or error as returned by it.
256 */
257 error = power_supply_for_each_psy(supply_node, __power_supply_find_supply_from_node);
258
259 return error ? (error == 1 ? 0 : error) : -EPROBE_DEFER;
260}
261
262static int power_supply_check_supplies(struct power_supply *psy)
263{
264 struct fwnode_handle *np;
265 int cnt = 0;
266
267 /* If there is already a list honor it */
268 if (psy->supplied_from && psy->num_supplies > 0)
269 return 0;
270
271 /* No device node found, nothing to do */
272 if (!psy->dev.fwnode)
273 return 0;
274
275 do {
276 int ret;
277
278 np = fwnode_find_reference(psy->dev.fwnode, "power-supplies", cnt++);
279 if (IS_ERR(np))
280 break;
281
282 ret = power_supply_find_supply_from_fwnode(np);
283 fwnode_handle_put(np);
284
285 if (ret) {
286 dev_dbg(&psy->dev, "Failed to find supply!\n");
287 return ret;
288 }
289 } while (!IS_ERR(np));
290
291 /* Missing valid "power-supplies" entries */
292 if (cnt == 1)
293 return 0;
294
295 /* All supplies found, allocate char ** array for filling */
296 psy->supplied_from = devm_kzalloc(&psy->dev, sizeof(*psy->supplied_from),
297 GFP_KERNEL);
298 if (!psy->supplied_from)
299 return -ENOMEM;
300
301 *psy->supplied_from = devm_kcalloc(&psy->dev,
302 cnt - 1, sizeof(**psy->supplied_from),
303 GFP_KERNEL);
304 if (!*psy->supplied_from)
305 return -ENOMEM;
306
307 return power_supply_populate_supplied_from(psy);
308}
309#else
310static int power_supply_check_supplies(struct power_supply *psy)
311{
312 int nval, ret;
313
314 if (!psy->dev.parent)
315 return 0;
316
317 nval = device_property_string_array_count(dev: psy->dev.parent, propname: "supplied-from");
318 if (nval <= 0)
319 return 0;
320
321 psy->supplied_from = devm_kmalloc_array(dev: &psy->dev, n: nval,
322 size: sizeof(char *), GFP_KERNEL);
323 if (!psy->supplied_from)
324 return -ENOMEM;
325
326 ret = device_property_read_string_array(dev: psy->dev.parent,
327 propname: "supplied-from", val: (const char **)psy->supplied_from, nval);
328 if (ret < 0)
329 return ret;
330
331 psy->num_supplies = nval;
332
333 return 0;
334}
335#endif
336
337struct psy_am_i_supplied_data {
338 struct power_supply *psy;
339 unsigned int count;
340};
341
342static int __power_supply_am_i_supplied(struct power_supply *epsy, void *_data)
343{
344 union power_supply_propval ret = {0,};
345 struct psy_am_i_supplied_data *data = _data;
346
347 if (__power_supply_is_supplied_by(supplier: epsy, supply: data->psy)) {
348 data->count++;
349 if (!epsy->desc->get_property(epsy, POWER_SUPPLY_PROP_ONLINE,
350 &ret))
351 return ret.intval;
352 }
353
354 return 0;
355}
356
357int power_supply_am_i_supplied(struct power_supply *psy)
358{
359 struct psy_am_i_supplied_data data = { psy, 0 };
360 int error;
361
362 error = power_supply_for_each_psy(&data, __power_supply_am_i_supplied);
363
364 dev_dbg(&psy->dev, "%s count %u err %d\n", __func__, data.count, error);
365
366 if (data.count == 0)
367 return -ENODEV;
368
369 return error;
370}
371EXPORT_SYMBOL_GPL(power_supply_am_i_supplied);
372
373static int __power_supply_is_system_supplied(struct power_supply *psy, void *data)
374{
375 union power_supply_propval ret = {0,};
376 unsigned int *count = data;
377
378 if (!psy->desc->get_property(psy, POWER_SUPPLY_PROP_SCOPE, &ret))
379 if (ret.intval == POWER_SUPPLY_SCOPE_DEVICE)
380 return 0;
381
382 (*count)++;
383 if (psy->desc->type != POWER_SUPPLY_TYPE_BATTERY)
384 if (!psy->desc->get_property(psy, POWER_SUPPLY_PROP_ONLINE,
385 &ret))
386 return ret.intval;
387
388 return 0;
389}
390
391int power_supply_is_system_supplied(void)
392{
393 int error;
394 unsigned int count = 0;
395
396 error = power_supply_for_each_psy(&count, __power_supply_is_system_supplied);
397
398 /*
399 * If no system scope power class device was found at all, most probably we
400 * are running on a desktop system, so assume we are on mains power.
401 */
402 if (count == 0)
403 return 1;
404
405 return error;
406}
407EXPORT_SYMBOL_GPL(power_supply_is_system_supplied);
408
409struct psy_get_supplier_prop_data {
410 struct power_supply *psy;
411 enum power_supply_property psp;
412 union power_supply_propval *val;
413};
414
415static int __power_supply_get_supplier_property(struct power_supply *epsy, void *_data)
416{
417 struct psy_get_supplier_prop_data *data = _data;
418
419 if (__power_supply_is_supplied_by(supplier: epsy, supply: data->psy))
420 if (!power_supply_get_property(psy: epsy, psp: data->psp, val: data->val))
421 return 1; /* Success */
422
423 return 0; /* Continue iterating */
424}
425
426int power_supply_get_property_from_supplier(struct power_supply *psy,
427 enum power_supply_property psp,
428 union power_supply_propval *val)
429{
430 struct psy_get_supplier_prop_data data = {
431 .psy = psy,
432 .psp = psp,
433 .val = val,
434 };
435 int ret;
436
437 /*
438 * This function is not intended for use with a supply with multiple
439 * suppliers, we simply pick the first supply to report the psp.
440 */
441 ret = power_supply_for_each_psy(&data, __power_supply_get_supplier_property);
442 if (ret < 0)
443 return ret;
444 if (ret == 0)
445 return -ENODEV;
446
447 return 0;
448}
449EXPORT_SYMBOL_GPL(power_supply_get_property_from_supplier);
450
451static int power_supply_match_device_by_name(struct device *dev, const void *data)
452{
453 const char *name = data;
454 struct power_supply *psy = dev_to_psy(dev);
455
456 return strcmp(psy->desc->name, name) == 0;
457}
458
459/**
460 * power_supply_get_by_name() - Search for a power supply and returns its ref
461 * @name: Power supply name to fetch
462 *
463 * If power supply was found, it increases reference count for the
464 * internal power supply's device. The user should power_supply_put()
465 * after usage.
466 *
467 * Return: On success returns a reference to a power supply with
468 * matching name equals to @name, a NULL otherwise.
469 */
470struct power_supply *power_supply_get_by_name(const char *name)
471{
472 struct power_supply *psy = NULL;
473 struct device *dev = class_find_device(class: &power_supply_class, NULL, data: name,
474 match: power_supply_match_device_by_name);
475
476 if (dev) {
477 psy = dev_to_psy(dev);
478 atomic_inc(v: &psy->use_cnt);
479 }
480
481 return psy;
482}
483EXPORT_SYMBOL_GPL(power_supply_get_by_name);
484
485/**
486 * power_supply_put() - Drop reference obtained with power_supply_get_by_name
487 * @psy: Reference to put
488 *
489 * The reference to power supply should be put before unregistering
490 * the power supply.
491 */
492void power_supply_put(struct power_supply *psy)
493{
494 atomic_dec(v: &psy->use_cnt);
495 put_device(dev: &psy->dev);
496}
497EXPORT_SYMBOL_GPL(power_supply_put);
498
499static int power_supply_match_device_fwnode(struct device *dev, const void *data)
500{
501 return dev->parent && dev_fwnode(dev->parent) == data;
502}
503
504/**
505 * power_supply_get_by_reference() - Search for a power supply and returns its ref
506 * @fwnode: Pointer to fwnode holding phandle property
507 * @property: Name of property holding a power supply name
508 *
509 * If power supply was found, it increases reference count for the
510 * internal power supply's device. The user should power_supply_put()
511 * after usage.
512 *
513 * Return: On success returns a reference to a power supply with
514 * matching name equals to value under @property, NULL or ERR_PTR otherwise.
515 */
516struct power_supply *power_supply_get_by_reference(struct fwnode_handle *fwnode,
517 const char *property)
518{
519 struct fwnode_handle *power_supply_fwnode;
520 struct power_supply *psy = NULL;
521 struct device *dev;
522
523 power_supply_fwnode = fwnode_find_reference(fwnode, name: property, index: 0);
524 if (IS_ERR(ptr: power_supply_fwnode))
525 return ERR_CAST(ptr: power_supply_fwnode);
526
527 dev = class_find_device(class: &power_supply_class, NULL, data: power_supply_fwnode,
528 match: power_supply_match_device_fwnode);
529
530 fwnode_handle_put(fwnode: power_supply_fwnode);
531
532 if (dev) {
533 psy = dev_to_psy(dev);
534 atomic_inc(v: &psy->use_cnt);
535 }
536
537 return psy;
538}
539EXPORT_SYMBOL_GPL(power_supply_get_by_reference);
540
541static void devm_power_supply_put(struct device *dev, void *res)
542{
543 struct power_supply **psy = res;
544
545 power_supply_put(*psy);
546}
547
548/**
549 * devm_power_supply_get_by_reference() - Resource managed version of
550 * power_supply_get_by_reference()
551 * @dev: Pointer to device holding phandle property
552 * @property: Name of property holding a power supply phandle
553 *
554 * Return: On success returns a reference to a power supply with
555 * matching name equals to value under @property, NULL or ERR_PTR otherwise.
556 */
557struct power_supply *devm_power_supply_get_by_reference(struct device *dev,
558 const char *property)
559{
560 struct power_supply **ptr, *psy;
561
562 if (!dev_fwnode(dev))
563 return ERR_PTR(error: -ENODEV);
564
565 ptr = devres_alloc(devm_power_supply_put, sizeof(*ptr), GFP_KERNEL);
566 if (!ptr)
567 return ERR_PTR(error: -ENOMEM);
568
569 psy = power_supply_get_by_reference(dev_fwnode(dev), property);
570 if (IS_ERR_OR_NULL(ptr: psy)) {
571 devres_free(res: ptr);
572 } else {
573 *ptr = psy;
574 devres_add(dev, res: ptr);
575 }
576 return psy;
577}
578EXPORT_SYMBOL_GPL(devm_power_supply_get_by_reference);
579
580int power_supply_get_battery_info(struct power_supply *psy,
581 struct power_supply_battery_info **info_out)
582{
583 struct power_supply_resistance_temp_table *resist_table;
584 struct power_supply_battery_info *info;
585 struct fwnode_handle *srcnode, *fwnode;
586 const char *value;
587 int err, len, index, proplen;
588 u32 *propdata __free(kfree) = NULL;
589 u32 min_max[2];
590
591 srcnode = dev_fwnode(&psy->dev);
592 if (!srcnode && psy->dev.parent)
593 srcnode = dev_fwnode(psy->dev.parent);
594
595 fwnode = fwnode_find_reference(fwnode: srcnode, name: "monitored-battery", index: 0);
596 if (IS_ERR(ptr: fwnode))
597 return PTR_ERR(ptr: fwnode);
598
599 err = fwnode_property_read_string(fwnode, propname: "compatible", val: &value);
600 if (err)
601 goto out_put_node;
602
603
604 /* Try static batteries first */
605 err = samsung_sdi_battery_get_info(dev: &psy->dev, compatible: value, info: &info);
606 if (!err)
607 goto out_ret_pointer;
608 else if (err == -ENODEV)
609 /*
610 * Device does not have a static battery.
611 * Proceed to look for a simple battery.
612 */
613 err = 0;
614
615 if (strcmp("simple-battery", value)) {
616 err = -ENODEV;
617 goto out_put_node;
618 }
619
620 info = devm_kzalloc(dev: &psy->dev, size: sizeof(*info), GFP_KERNEL);
621 if (!info) {
622 err = -ENOMEM;
623 goto out_put_node;
624 }
625
626 info->technology = POWER_SUPPLY_TECHNOLOGY_UNKNOWN;
627 info->energy_full_design_uwh = -EINVAL;
628 info->charge_full_design_uah = -EINVAL;
629 info->voltage_min_design_uv = -EINVAL;
630 info->voltage_max_design_uv = -EINVAL;
631 info->precharge_current_ua = -EINVAL;
632 info->charge_term_current_ua = -EINVAL;
633 info->constant_charge_current_max_ua = -EINVAL;
634 info->constant_charge_voltage_max_uv = -EINVAL;
635 info->tricklecharge_current_ua = -EINVAL;
636 info->precharge_voltage_max_uv = -EINVAL;
637 info->charge_restart_voltage_uv = -EINVAL;
638 info->overvoltage_limit_uv = -EINVAL;
639 info->maintenance_charge = NULL;
640 info->alert_low_temp_charge_current_ua = -EINVAL;
641 info->alert_low_temp_charge_voltage_uv = -EINVAL;
642 info->alert_high_temp_charge_current_ua = -EINVAL;
643 info->alert_high_temp_charge_voltage_uv = -EINVAL;
644 info->temp_ambient_alert_min = INT_MIN;
645 info->temp_ambient_alert_max = INT_MAX;
646 info->temp_alert_min = INT_MIN;
647 info->temp_alert_max = INT_MAX;
648 info->temp_min = INT_MIN;
649 info->temp_max = INT_MAX;
650 info->factory_internal_resistance_uohm = -EINVAL;
651 info->resist_table = NULL;
652 info->bti_resistance_ohm = -EINVAL;
653 info->bti_resistance_tolerance = -EINVAL;
654
655 for (index = 0; index < POWER_SUPPLY_OCV_TEMP_MAX; index++) {
656 info->ocv_table[index] = NULL;
657 info->ocv_temp[index] = -EINVAL;
658 info->ocv_table_size[index] = -EINVAL;
659 }
660
661 /* The property and field names below must correspond to elements
662 * in enum power_supply_property. For reasoning, see
663 * Documentation/power/power_supply_class.rst.
664 */
665
666 if (!fwnode_property_read_string(fwnode, propname: "device-chemistry", val: &value)) {
667 if (!strcmp("nickel-cadmium", value))
668 info->technology = POWER_SUPPLY_TECHNOLOGY_NiCd;
669 else if (!strcmp("nickel-metal-hydride", value))
670 info->technology = POWER_SUPPLY_TECHNOLOGY_NiMH;
671 else if (!strcmp("lithium-ion", value))
672 /* Imprecise lithium-ion type */
673 info->technology = POWER_SUPPLY_TECHNOLOGY_LION;
674 else if (!strcmp("lithium-ion-polymer", value))
675 info->technology = POWER_SUPPLY_TECHNOLOGY_LIPO;
676 else if (!strcmp("lithium-ion-iron-phosphate", value))
677 info->technology = POWER_SUPPLY_TECHNOLOGY_LiFe;
678 else if (!strcmp("lithium-ion-manganese-oxide", value))
679 info->technology = POWER_SUPPLY_TECHNOLOGY_LiMn;
680 else
681 dev_warn(&psy->dev, "%s unknown battery type\n", value);
682 }
683
684 fwnode_property_read_u32(fwnode, propname: "energy-full-design-microwatt-hours",
685 val: &info->energy_full_design_uwh);
686 fwnode_property_read_u32(fwnode, propname: "charge-full-design-microamp-hours",
687 val: &info->charge_full_design_uah);
688 fwnode_property_read_u32(fwnode, propname: "voltage-min-design-microvolt",
689 val: &info->voltage_min_design_uv);
690 fwnode_property_read_u32(fwnode, propname: "voltage-max-design-microvolt",
691 val: &info->voltage_max_design_uv);
692 fwnode_property_read_u32(fwnode, propname: "trickle-charge-current-microamp",
693 val: &info->tricklecharge_current_ua);
694 fwnode_property_read_u32(fwnode, propname: "precharge-current-microamp",
695 val: &info->precharge_current_ua);
696 fwnode_property_read_u32(fwnode, propname: "precharge-upper-limit-microvolt",
697 val: &info->precharge_voltage_max_uv);
698 fwnode_property_read_u32(fwnode, propname: "charge-term-current-microamp",
699 val: &info->charge_term_current_ua);
700 fwnode_property_read_u32(fwnode, propname: "re-charge-voltage-microvolt",
701 val: &info->charge_restart_voltage_uv);
702 fwnode_property_read_u32(fwnode, propname: "over-voltage-threshold-microvolt",
703 val: &info->overvoltage_limit_uv);
704 fwnode_property_read_u32(fwnode, propname: "constant-charge-current-max-microamp",
705 val: &info->constant_charge_current_max_ua);
706 fwnode_property_read_u32(fwnode, propname: "constant-charge-voltage-max-microvolt",
707 val: &info->constant_charge_voltage_max_uv);
708 fwnode_property_read_u32(fwnode, propname: "factory-internal-resistance-micro-ohms",
709 val: &info->factory_internal_resistance_uohm);
710
711 if (!fwnode_property_read_u32_array(fwnode, propname: "ambient-celsius",
712 val: min_max, ARRAY_SIZE(min_max))) {
713 info->temp_ambient_alert_min = min_max[0];
714 info->temp_ambient_alert_max = min_max[1];
715 }
716 if (!fwnode_property_read_u32_array(fwnode, propname: "alert-celsius",
717 val: min_max, ARRAY_SIZE(min_max))) {
718 info->temp_alert_min = min_max[0];
719 info->temp_alert_max = min_max[1];
720 }
721 if (!fwnode_property_read_u32_array(fwnode, propname: "operating-range-celsius",
722 val: min_max, ARRAY_SIZE(min_max))) {
723 info->temp_min = min_max[0];
724 info->temp_max = min_max[1];
725 }
726
727 len = fwnode_property_count_u32(fwnode, propname: "ocv-capacity-celsius");
728 if (len < 0 && len != -EINVAL) {
729 err = len;
730 goto out_put_node;
731 } else if (len > POWER_SUPPLY_OCV_TEMP_MAX) {
732 dev_err(&psy->dev, "Too many temperature values\n");
733 err = -EINVAL;
734 goto out_put_node;
735 } else if (len > 0) {
736 fwnode_property_read_u32_array(fwnode, propname: "ocv-capacity-celsius",
737 val: info->ocv_temp, nval: len);
738 }
739
740 for (index = 0; index < len; index++) {
741 struct power_supply_battery_ocv_table *table;
742 int i, tab_len;
743
744 char *propname __free(kfree) = kasprintf(GFP_KERNEL, fmt: "ocv-capacity-table-%d",
745 index);
746 if (!propname) {
747 power_supply_put_battery_info(psy, info);
748 err = -ENOMEM;
749 goto out_put_node;
750 }
751 proplen = fwnode_property_count_u32(fwnode, propname);
752 if (proplen < 0 || proplen % 2 != 0) {
753 dev_err(&psy->dev, "failed to get %s\n", propname);
754 power_supply_put_battery_info(psy, info);
755 err = -EINVAL;
756 goto out_put_node;
757 }
758
759 u32 *propdata __free(kfree) = kcalloc(proplen, sizeof(*propdata), GFP_KERNEL);
760 if (!propdata) {
761 power_supply_put_battery_info(psy, info);
762 err = -EINVAL;
763 goto out_put_node;
764 }
765 err = fwnode_property_read_u32_array(fwnode, propname, val: propdata, nval: proplen);
766 if (err < 0) {
767 dev_err(&psy->dev, "failed to get %s\n", propname);
768 power_supply_put_battery_info(psy, info);
769 goto out_put_node;
770 }
771
772 tab_len = proplen / 2;
773 info->ocv_table_size[index] = tab_len;
774
775 info->ocv_table[index] = table =
776 devm_kcalloc(dev: &psy->dev, n: tab_len, size: sizeof(*table), GFP_KERNEL);
777 if (!info->ocv_table[index]) {
778 power_supply_put_battery_info(psy, info);
779 err = -ENOMEM;
780 goto out_put_node;
781 }
782
783 for (i = 0; i < tab_len; i++) {
784 table[i].ocv = propdata[i*2];
785 table[i].capacity = propdata[i*2+1];
786 }
787 }
788
789 proplen = fwnode_property_count_u32(fwnode, propname: "resistance-temp-table");
790 if (proplen == 0 || proplen == -EINVAL) {
791 err = 0;
792 goto out_ret_pointer;
793 } else if (proplen < 0 || proplen % 2 != 0) {
794 power_supply_put_battery_info(psy, info);
795 err = (proplen < 0) ? proplen : -EINVAL;
796 goto out_put_node;
797 }
798
799 propdata = kcalloc(proplen, sizeof(*propdata), GFP_KERNEL);
800 if (!propdata) {
801 power_supply_put_battery_info(psy, info);
802 err = -ENOMEM;
803 goto out_put_node;
804 }
805
806 err = fwnode_property_read_u32_array(fwnode, propname: "resistance-temp-table",
807 val: propdata, nval: proplen);
808 if (err < 0) {
809 power_supply_put_battery_info(psy, info);
810 goto out_put_node;
811 }
812
813 info->resist_table_size = proplen / 2;
814 info->resist_table = resist_table = devm_kcalloc(dev: &psy->dev,
815 n: info->resist_table_size,
816 size: sizeof(*resist_table),
817 GFP_KERNEL);
818 if (!info->resist_table) {
819 power_supply_put_battery_info(psy, info);
820 err = -ENOMEM;
821 goto out_put_node;
822 }
823
824 for (index = 0; index < info->resist_table_size; index++) {
825 resist_table[index].temp = propdata[index*2];
826 resist_table[index].resistance = propdata[index*2+1];
827 }
828
829out_ret_pointer:
830 /* Finally return the whole thing */
831 *info_out = info;
832
833out_put_node:
834 fwnode_handle_put(fwnode);
835 return err;
836}
837EXPORT_SYMBOL_GPL(power_supply_get_battery_info);
838
839void power_supply_put_battery_info(struct power_supply *psy,
840 struct power_supply_battery_info *info)
841{
842 int i;
843
844 for (i = 0; i < POWER_SUPPLY_OCV_TEMP_MAX; i++) {
845 if (info->ocv_table[i])
846 devm_kfree(dev: &psy->dev, p: info->ocv_table[i]);
847 }
848
849 if (info->resist_table)
850 devm_kfree(dev: &psy->dev, p: info->resist_table);
851
852 devm_kfree(dev: &psy->dev, p: info);
853}
854EXPORT_SYMBOL_GPL(power_supply_put_battery_info);
855
856const enum power_supply_property power_supply_battery_info_properties[] = {
857 POWER_SUPPLY_PROP_TECHNOLOGY,
858 POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN,
859 POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
860 POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
861 POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN,
862 POWER_SUPPLY_PROP_PRECHARGE_CURRENT,
863 POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT,
864 POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX,
865 POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX,
866 POWER_SUPPLY_PROP_TEMP_AMBIENT_ALERT_MIN,
867 POWER_SUPPLY_PROP_TEMP_AMBIENT_ALERT_MAX,
868 POWER_SUPPLY_PROP_TEMP_ALERT_MIN,
869 POWER_SUPPLY_PROP_TEMP_ALERT_MAX,
870 POWER_SUPPLY_PROP_TEMP_MIN,
871 POWER_SUPPLY_PROP_TEMP_MAX,
872};
873EXPORT_SYMBOL_GPL(power_supply_battery_info_properties);
874
875const size_t power_supply_battery_info_properties_size = ARRAY_SIZE(power_supply_battery_info_properties);
876EXPORT_SYMBOL_GPL(power_supply_battery_info_properties_size);
877
878bool power_supply_battery_info_has_prop(struct power_supply_battery_info *info,
879 enum power_supply_property psp)
880{
881 if (!info)
882 return false;
883
884 switch (psp) {
885 case POWER_SUPPLY_PROP_TECHNOLOGY:
886 return info->technology != POWER_SUPPLY_TECHNOLOGY_UNKNOWN;
887 case POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN:
888 return info->energy_full_design_uwh >= 0;
889 case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
890 return info->charge_full_design_uah >= 0;
891 case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
892 return info->voltage_min_design_uv >= 0;
893 case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN:
894 return info->voltage_max_design_uv >= 0;
895 case POWER_SUPPLY_PROP_PRECHARGE_CURRENT:
896 return info->precharge_current_ua >= 0;
897 case POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT:
898 return info->charge_term_current_ua >= 0;
899 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX:
900 return info->constant_charge_current_max_ua >= 0;
901 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX:
902 return info->constant_charge_voltage_max_uv >= 0;
903 case POWER_SUPPLY_PROP_TEMP_AMBIENT_ALERT_MIN:
904 return info->temp_ambient_alert_min > INT_MIN;
905 case POWER_SUPPLY_PROP_TEMP_AMBIENT_ALERT_MAX:
906 return info->temp_ambient_alert_max < INT_MAX;
907 case POWER_SUPPLY_PROP_TEMP_ALERT_MIN:
908 return info->temp_alert_min > INT_MIN;
909 case POWER_SUPPLY_PROP_TEMP_ALERT_MAX:
910 return info->temp_alert_max < INT_MAX;
911 case POWER_SUPPLY_PROP_TEMP_MIN:
912 return info->temp_min > INT_MIN;
913 case POWER_SUPPLY_PROP_TEMP_MAX:
914 return info->temp_max < INT_MAX;
915 default:
916 return false;
917 }
918}
919EXPORT_SYMBOL_GPL(power_supply_battery_info_has_prop);
920
921int power_supply_battery_info_get_prop(struct power_supply_battery_info *info,
922 enum power_supply_property psp,
923 union power_supply_propval *val)
924{
925 if (!info)
926 return -EINVAL;
927
928 if (!power_supply_battery_info_has_prop(info, psp))
929 return -EINVAL;
930
931 switch (psp) {
932 case POWER_SUPPLY_PROP_TECHNOLOGY:
933 val->intval = info->technology;
934 return 0;
935 case POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN:
936 val->intval = info->energy_full_design_uwh;
937 return 0;
938 case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
939 val->intval = info->charge_full_design_uah;
940 return 0;
941 case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
942 val->intval = info->voltage_min_design_uv;
943 return 0;
944 case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN:
945 val->intval = info->voltage_max_design_uv;
946 return 0;
947 case POWER_SUPPLY_PROP_PRECHARGE_CURRENT:
948 val->intval = info->precharge_current_ua;
949 return 0;
950 case POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT:
951 val->intval = info->charge_term_current_ua;
952 return 0;
953 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX:
954 val->intval = info->constant_charge_current_max_ua;
955 return 0;
956 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX:
957 val->intval = info->constant_charge_voltage_max_uv;
958 return 0;
959 case POWER_SUPPLY_PROP_TEMP_AMBIENT_ALERT_MIN:
960 val->intval = info->temp_ambient_alert_min;
961 return 0;
962 case POWER_SUPPLY_PROP_TEMP_AMBIENT_ALERT_MAX:
963 val->intval = info->temp_ambient_alert_max;
964 return 0;
965 case POWER_SUPPLY_PROP_TEMP_ALERT_MIN:
966 val->intval = info->temp_alert_min;
967 return 0;
968 case POWER_SUPPLY_PROP_TEMP_ALERT_MAX:
969 val->intval = info->temp_alert_max;
970 return 0;
971 case POWER_SUPPLY_PROP_TEMP_MIN:
972 val->intval = info->temp_min;
973 return 0;
974 case POWER_SUPPLY_PROP_TEMP_MAX:
975 val->intval = info->temp_max;
976 return 0;
977 default:
978 return -EINVAL;
979 }
980}
981EXPORT_SYMBOL_GPL(power_supply_battery_info_get_prop);
982
983/**
984 * power_supply_temp2resist_simple() - find the battery internal resistance
985 * percent from temperature
986 * @table: Pointer to battery resistance temperature table
987 * @table_len: The table length
988 * @temp: Current temperature
989 *
990 * This helper function is used to look up battery internal resistance percent
991 * according to current temperature value from the resistance temperature table,
992 * and the table must be ordered descending. Then the actual battery internal
993 * resistance = the ideal battery internal resistance * percent / 100.
994 *
995 * Return: the battery internal resistance percent
996 */
997int power_supply_temp2resist_simple(const struct power_supply_resistance_temp_table *table,
998 int table_len, int temp)
999{
1000 int i, high, low;
1001
1002 for (i = 0; i < table_len; i++)
1003 if (temp > table[i].temp)
1004 break;
1005
1006 /* The library function will deal with high == low */
1007 if (i == 0)
1008 high = low = i;
1009 else if (i == table_len)
1010 high = low = i - 1;
1011 else
1012 high = (low = i) - 1;
1013
1014 return fixp_linear_interpolate(x0: table[low].temp,
1015 y0: table[low].resistance,
1016 x1: table[high].temp,
1017 y1: table[high].resistance,
1018 x: temp);
1019}
1020EXPORT_SYMBOL_GPL(power_supply_temp2resist_simple);
1021
1022/**
1023 * power_supply_vbat2ri() - find the battery internal resistance
1024 * from the battery voltage
1025 * @info: The battery information container
1026 * @vbat_uv: The battery voltage in microvolt
1027 * @charging: If we are charging (true) or not (false)
1028 *
1029 * This helper function is used to look up battery internal resistance
1030 * according to current battery voltage. Depending on whether the battery
1031 * is currently charging or not, different resistance will be returned.
1032 *
1033 * Returns the internal resistance in microohm or negative error code.
1034 */
1035int power_supply_vbat2ri(struct power_supply_battery_info *info,
1036 int vbat_uv, bool charging)
1037{
1038 const struct power_supply_vbat_ri_table *vbat2ri;
1039 int table_len;
1040 int i, high, low;
1041
1042 /*
1043 * If we are charging, and the battery supplies a separate table
1044 * for this state, we use that in order to compensate for the
1045 * charging voltage. Otherwise we use the main table.
1046 */
1047 if (charging && info->vbat2ri_charging) {
1048 vbat2ri = info->vbat2ri_charging;
1049 table_len = info->vbat2ri_charging_size;
1050 } else {
1051 vbat2ri = info->vbat2ri_discharging;
1052 table_len = info->vbat2ri_discharging_size;
1053 }
1054
1055 /*
1056 * If no tables are specified, or if we are above the highest voltage in
1057 * the voltage table, just return the factory specified internal resistance.
1058 */
1059 if (!vbat2ri || (table_len <= 0) || (vbat_uv > vbat2ri[0].vbat_uv)) {
1060 if (charging && (info->factory_internal_resistance_charging_uohm > 0))
1061 return info->factory_internal_resistance_charging_uohm;
1062 else
1063 return info->factory_internal_resistance_uohm;
1064 }
1065
1066 /* Break loop at table_len - 1 because that is the highest index */
1067 for (i = 0; i < table_len - 1; i++)
1068 if (vbat_uv > vbat2ri[i].vbat_uv)
1069 break;
1070
1071 /* The library function will deal with high == low */
1072 if ((i == 0) || (i == (table_len - 1)))
1073 high = i;
1074 else
1075 high = i - 1;
1076 low = i;
1077
1078 return fixp_linear_interpolate(x0: vbat2ri[low].vbat_uv,
1079 y0: vbat2ri[low].ri_uohm,
1080 x1: vbat2ri[high].vbat_uv,
1081 y1: vbat2ri[high].ri_uohm,
1082 x: vbat_uv);
1083}
1084EXPORT_SYMBOL_GPL(power_supply_vbat2ri);
1085
1086const struct power_supply_maintenance_charge_table *
1087power_supply_get_maintenance_charging_setting(struct power_supply_battery_info *info,
1088 int index)
1089{
1090 if (index >= info->maintenance_charge_size)
1091 return NULL;
1092 return &info->maintenance_charge[index];
1093}
1094EXPORT_SYMBOL_GPL(power_supply_get_maintenance_charging_setting);
1095
1096/**
1097 * power_supply_ocv2cap_simple() - find the battery capacity
1098 * @table: Pointer to battery OCV lookup table
1099 * @table_len: OCV table length
1100 * @ocv: Current OCV value
1101 *
1102 * This helper function is used to look up battery capacity according to
1103 * current OCV value from one OCV table, and the OCV table must be ordered
1104 * descending.
1105 *
1106 * Return: the battery capacity.
1107 */
1108int power_supply_ocv2cap_simple(const struct power_supply_battery_ocv_table *table,
1109 int table_len, int ocv)
1110{
1111 int i, high, low;
1112
1113 for (i = 0; i < table_len; i++)
1114 if (ocv > table[i].ocv)
1115 break;
1116
1117 /* The library function will deal with high == low */
1118 if (i == 0)
1119 high = low = i;
1120 else if (i == table_len)
1121 high = low = i - 1;
1122 else
1123 high = (low = i) - 1;
1124
1125 return fixp_linear_interpolate(x0: table[low].ocv,
1126 y0: table[low].capacity,
1127 x1: table[high].ocv,
1128 y1: table[high].capacity,
1129 x: ocv);
1130}
1131EXPORT_SYMBOL_GPL(power_supply_ocv2cap_simple);
1132
1133const struct power_supply_battery_ocv_table *
1134power_supply_find_ocv2cap_table(struct power_supply_battery_info *info,
1135 int temp, int *table_len)
1136{
1137 int best_temp_diff = INT_MAX, temp_diff;
1138 u8 i, best_index = 0;
1139
1140 if (!info->ocv_table[0])
1141 return NULL;
1142
1143 for (i = 0; i < POWER_SUPPLY_OCV_TEMP_MAX; i++) {
1144 /* Out of capacity tables */
1145 if (!info->ocv_table[i])
1146 break;
1147
1148 temp_diff = abs(info->ocv_temp[i] - temp);
1149
1150 if (temp_diff < best_temp_diff) {
1151 best_temp_diff = temp_diff;
1152 best_index = i;
1153 }
1154 }
1155
1156 *table_len = info->ocv_table_size[best_index];
1157 return info->ocv_table[best_index];
1158}
1159EXPORT_SYMBOL_GPL(power_supply_find_ocv2cap_table);
1160
1161int power_supply_batinfo_ocv2cap(struct power_supply_battery_info *info,
1162 int ocv, int temp)
1163{
1164 const struct power_supply_battery_ocv_table *table;
1165 int table_len;
1166
1167 table = power_supply_find_ocv2cap_table(info, temp, &table_len);
1168 if (!table)
1169 return -EINVAL;
1170
1171 return power_supply_ocv2cap_simple(table, table_len, ocv);
1172}
1173EXPORT_SYMBOL_GPL(power_supply_batinfo_ocv2cap);
1174
1175bool power_supply_battery_bti_in_range(struct power_supply_battery_info *info,
1176 int resistance)
1177{
1178 int low, high;
1179
1180 /* Nothing like this can be checked */
1181 if (info->bti_resistance_ohm <= 0)
1182 return false;
1183
1184 /* This will be extremely strict and unlikely to work */
1185 if (info->bti_resistance_tolerance <= 0)
1186 return (info->bti_resistance_ohm == resistance);
1187
1188 low = info->bti_resistance_ohm -
1189 (info->bti_resistance_ohm * info->bti_resistance_tolerance) / 100;
1190 high = info->bti_resistance_ohm +
1191 (info->bti_resistance_ohm * info->bti_resistance_tolerance) / 100;
1192
1193 return ((resistance >= low) && (resistance <= high));
1194}
1195EXPORT_SYMBOL_GPL(power_supply_battery_bti_in_range);
1196
1197static bool psy_desc_has_property(const struct power_supply_desc *psy_desc,
1198 enum power_supply_property psp)
1199{
1200 bool found = false;
1201 int i;
1202
1203 for (i = 0; i < psy_desc->num_properties; i++) {
1204 if (psy_desc->properties[i] == psp) {
1205 found = true;
1206 break;
1207 }
1208 }
1209
1210 return found;
1211}
1212
1213bool power_supply_ext_has_property(const struct power_supply_ext *psy_ext,
1214 enum power_supply_property psp)
1215{
1216 int i;
1217
1218 for (i = 0; i < psy_ext->num_properties; i++)
1219 if (psy_ext->properties[i] == psp)
1220 return true;
1221
1222 return false;
1223}
1224
1225bool power_supply_has_property(struct power_supply *psy,
1226 enum power_supply_property psp)
1227{
1228 struct power_supply_ext_registration *reg;
1229
1230 if (psy_desc_has_property(psy_desc: psy->desc, psp))
1231 return true;
1232
1233 if (power_supply_battery_info_has_prop(psy->battery_info, psp))
1234 return true;
1235
1236 power_supply_for_each_extension(reg, psy) {
1237 if (power_supply_ext_has_property(psy_ext: reg->ext, psp))
1238 return true;
1239 }
1240
1241 return false;
1242}
1243
1244static int __power_supply_get_property(struct power_supply *psy, enum power_supply_property psp,
1245 union power_supply_propval *val, bool use_extensions)
1246{
1247 struct power_supply_ext_registration *reg;
1248
1249 if (atomic_read(v: &psy->use_cnt) <= 0) {
1250 if (!psy->initialized)
1251 return -EAGAIN;
1252 return -ENODEV;
1253 }
1254
1255 if (use_extensions) {
1256 scoped_guard(rwsem_read, &psy->extensions_sem) {
1257 power_supply_for_each_extension(reg, psy) {
1258 if (!power_supply_ext_has_property(psy_ext: reg->ext, psp))
1259 continue;
1260
1261 return reg->ext->get_property(psy, reg->ext, reg->data, psp, val);
1262 }
1263 }
1264 }
1265
1266 if (psy_desc_has_property(psy_desc: psy->desc, psp))
1267 return psy->desc->get_property(psy, psp, val);
1268 else if (power_supply_battery_info_has_prop(psy->battery_info, psp))
1269 return power_supply_battery_info_get_prop(psy->battery_info, psp, val);
1270 else
1271 return -EINVAL;
1272}
1273
1274int power_supply_get_property(struct power_supply *psy, enum power_supply_property psp,
1275 union power_supply_propval *val)
1276{
1277 return __power_supply_get_property(psy, psp, val, use_extensions: true);
1278}
1279EXPORT_SYMBOL_GPL(power_supply_get_property);
1280
1281/**
1282 * power_supply_get_property_direct - Read a power supply property without checking for extensions
1283 * @psy: The power supply
1284 * @psp: The power supply property to read
1285 * @val: The resulting value of the power supply property
1286 *
1287 * Read a power supply property without taking into account any power supply extensions registered
1288 * on the given power supply. This is mostly useful for power supply extensions that want to access
1289 * their own power supply as using power_supply_get_property() directly will result in a potential
1290 * deadlock.
1291 *
1292 * Return: 0 on success or negative error code on failure.
1293 */
1294int power_supply_get_property_direct(struct power_supply *psy, enum power_supply_property psp,
1295 union power_supply_propval *val)
1296{
1297 return __power_supply_get_property(psy, psp, val, use_extensions: false);
1298}
1299EXPORT_SYMBOL_GPL(power_supply_get_property_direct);
1300
1301
1302static int __power_supply_set_property(struct power_supply *psy, enum power_supply_property psp,
1303 const union power_supply_propval *val, bool use_extensions)
1304{
1305 struct power_supply_ext_registration *reg;
1306
1307 if (atomic_read(v: &psy->use_cnt) <= 0)
1308 return -ENODEV;
1309
1310 if (use_extensions) {
1311 scoped_guard(rwsem_read, &psy->extensions_sem) {
1312 power_supply_for_each_extension(reg, psy) {
1313 if (!power_supply_ext_has_property(psy_ext: reg->ext, psp))
1314 continue;
1315
1316 if (reg->ext->set_property)
1317 return reg->ext->set_property(psy, reg->ext, reg->data,
1318 psp, val);
1319 else
1320 return -ENODEV;
1321 }
1322 }
1323 }
1324
1325 if (!psy->desc->set_property)
1326 return -ENODEV;
1327
1328 return psy->desc->set_property(psy, psp, val);
1329}
1330
1331int power_supply_set_property(struct power_supply *psy, enum power_supply_property psp,
1332 const union power_supply_propval *val)
1333{
1334 return __power_supply_set_property(psy, psp, val, use_extensions: true);
1335}
1336EXPORT_SYMBOL_GPL(power_supply_set_property);
1337
1338/**
1339 * power_supply_set_property_direct - Write a power supply property without checking for extensions
1340 * @psy: The power supply
1341 * @psp: The power supply property to write
1342 * @val: The value to write to the power supply property
1343 *
1344 * Write a power supply property without taking into account any power supply extensions registered
1345 * on the given power supply. This is mostly useful for power supply extensions that want to access
1346 * their own power supply as using power_supply_set_property() directly will result in a potential
1347 * deadlock.
1348 *
1349 * Return: 0 on success or negative error code on failure.
1350 */
1351int power_supply_set_property_direct(struct power_supply *psy, enum power_supply_property psp,
1352 const union power_supply_propval *val)
1353{
1354 return __power_supply_set_property(psy, psp, val, use_extensions: false);
1355}
1356EXPORT_SYMBOL_GPL(power_supply_set_property_direct);
1357
1358int power_supply_property_is_writeable(struct power_supply *psy,
1359 enum power_supply_property psp)
1360{
1361 struct power_supply_ext_registration *reg;
1362
1363 power_supply_for_each_extension(reg, psy) {
1364 if (power_supply_ext_has_property(psy_ext: reg->ext, psp)) {
1365 if (reg->ext->property_is_writeable)
1366 return reg->ext->property_is_writeable(psy, reg->ext,
1367 reg->data, psp);
1368 else
1369 return 0;
1370 }
1371 }
1372
1373 if (!psy->desc->property_is_writeable)
1374 return 0;
1375
1376 return psy->desc->property_is_writeable(psy, psp);
1377}
1378
1379void power_supply_external_power_changed(struct power_supply *psy)
1380{
1381 if (atomic_read(v: &psy->use_cnt) <= 0 ||
1382 !psy->desc->external_power_changed)
1383 return;
1384
1385 psy->desc->external_power_changed(psy);
1386}
1387EXPORT_SYMBOL_GPL(power_supply_external_power_changed);
1388
1389int power_supply_powers(struct power_supply *psy, struct device *dev)
1390{
1391 return sysfs_create_link(kobj: &psy->dev.kobj, target: &dev->kobj, name: "powers");
1392}
1393EXPORT_SYMBOL_GPL(power_supply_powers);
1394
1395static int power_supply_update_sysfs_and_hwmon(struct power_supply *psy)
1396{
1397 unsigned long flags;
1398
1399 spin_lock_irqsave(&psy->changed_lock, flags);
1400 psy->update_groups = true;
1401 spin_unlock_irqrestore(lock: &psy->changed_lock, flags);
1402
1403 power_supply_changed(psy);
1404
1405 power_supply_remove_hwmon_sysfs(psy);
1406 return power_supply_add_hwmon_sysfs(psy);
1407}
1408
1409int power_supply_register_extension(struct power_supply *psy, const struct power_supply_ext *ext,
1410 struct device *dev, void *data)
1411{
1412 struct power_supply_ext_registration *reg;
1413 size_t i;
1414 int ret;
1415
1416 if (!psy || !dev || !ext || !ext->name || !ext->properties || !ext->num_properties)
1417 return -EINVAL;
1418
1419 guard(rwsem_write)(T: &psy->extensions_sem);
1420
1421 power_supply_for_each_extension(reg, psy)
1422 if (strcmp(ext->name, reg->ext->name) == 0)
1423 return -EEXIST;
1424
1425 for (i = 0; i < ext->num_properties; i++)
1426 if (power_supply_has_property(psy, psp: ext->properties[i]))
1427 return -EEXIST;
1428
1429 reg = kmalloc(sizeof(*reg), GFP_KERNEL);
1430 if (!reg)
1431 return -ENOMEM;
1432
1433 reg->ext = ext;
1434 reg->dev = dev;
1435 reg->data = data;
1436 list_add(new: &reg->list_head, head: &psy->extensions);
1437
1438 ret = power_supply_sysfs_add_extension(psy, ext, dev);
1439 if (ret)
1440 goto sysfs_add_failed;
1441
1442 ret = power_supply_update_sysfs_and_hwmon(psy);
1443 if (ret)
1444 goto sysfs_hwmon_failed;
1445
1446 return 0;
1447
1448sysfs_hwmon_failed:
1449 power_supply_sysfs_remove_extension(psy, ext);
1450sysfs_add_failed:
1451 list_del(entry: &reg->list_head);
1452 kfree(objp: reg);
1453 return ret;
1454}
1455EXPORT_SYMBOL_GPL(power_supply_register_extension);
1456
1457void power_supply_unregister_extension(struct power_supply *psy, const struct power_supply_ext *ext)
1458{
1459 struct power_supply_ext_registration *reg;
1460
1461 guard(rwsem_write)(T: &psy->extensions_sem);
1462
1463 power_supply_for_each_extension(reg, psy) {
1464 if (reg->ext == ext) {
1465 list_del(entry: &reg->list_head);
1466 power_supply_sysfs_remove_extension(psy, ext);
1467 kfree(objp: reg);
1468 power_supply_update_sysfs_and_hwmon(psy);
1469 return;
1470 }
1471 }
1472
1473 dev_warn(&psy->dev, "Trying to unregister invalid extension");
1474}
1475EXPORT_SYMBOL_GPL(power_supply_unregister_extension);
1476
1477static void power_supply_dev_release(struct device *dev)
1478{
1479 struct power_supply *psy = to_power_supply(dev);
1480
1481 dev_dbg(dev, "%s\n", __func__);
1482 kfree(objp: psy);
1483}
1484
1485int power_supply_reg_notifier(struct notifier_block *nb)
1486{
1487 return blocking_notifier_chain_register(nh: &power_supply_notifier, nb);
1488}
1489EXPORT_SYMBOL_GPL(power_supply_reg_notifier);
1490
1491void power_supply_unreg_notifier(struct notifier_block *nb)
1492{
1493 blocking_notifier_chain_unregister(nh: &power_supply_notifier, nb);
1494}
1495EXPORT_SYMBOL_GPL(power_supply_unreg_notifier);
1496
1497#ifdef CONFIG_THERMAL
1498static int power_supply_read_temp(struct thermal_zone_device *tzd,
1499 int *temp)
1500{
1501 struct power_supply *psy;
1502 union power_supply_propval val;
1503 int ret;
1504
1505 WARN_ON(tzd == NULL);
1506 psy = thermal_zone_device_priv(tzd);
1507 ret = power_supply_get_property(psy, POWER_SUPPLY_PROP_TEMP, &val);
1508 if (ret)
1509 return ret;
1510
1511 /* Convert tenths of degree Celsius to milli degree Celsius. */
1512 *temp = val.intval * 100;
1513
1514 return ret;
1515}
1516
1517static const struct thermal_zone_device_ops psy_tzd_ops = {
1518 .get_temp = power_supply_read_temp,
1519};
1520
1521static int psy_register_thermal(struct power_supply *psy)
1522{
1523 int ret;
1524
1525 if (psy->desc->no_thermal)
1526 return 0;
1527
1528 /* Register battery zone device psy reports temperature */
1529 if (psy_desc_has_property(psy_desc: psy->desc, psp: POWER_SUPPLY_PROP_TEMP)) {
1530 /* Prefer our hwmon device and avoid duplicates */
1531 struct thermal_zone_params tzp = {
1532 .no_hwmon = IS_ENABLED(CONFIG_POWER_SUPPLY_HWMON)
1533 };
1534 psy->tzd = thermal_tripless_zone_device_register(type: psy->desc->name,
1535 devdata: psy, ops: &psy_tzd_ops, tzp: &tzp);
1536 if (IS_ERR(ptr: psy->tzd))
1537 return PTR_ERR(ptr: psy->tzd);
1538 ret = thermal_zone_device_enable(tz: psy->tzd);
1539 if (ret)
1540 thermal_zone_device_unregister(tz: psy->tzd);
1541 return ret;
1542 }
1543
1544 return 0;
1545}
1546
1547static void psy_unregister_thermal(struct power_supply *psy)
1548{
1549 if (IS_ERR_OR_NULL(ptr: psy->tzd))
1550 return;
1551 thermal_zone_device_unregister(tz: psy->tzd);
1552}
1553
1554#else
1555static int psy_register_thermal(struct power_supply *psy)
1556{
1557 return 0;
1558}
1559
1560static void psy_unregister_thermal(struct power_supply *psy)
1561{
1562}
1563#endif
1564
1565static struct power_supply *__must_check
1566__power_supply_register(struct device *parent,
1567 const struct power_supply_desc *desc,
1568 const struct power_supply_config *cfg)
1569{
1570 struct device *dev;
1571 struct power_supply *psy;
1572 int rc;
1573
1574 if (!desc || !desc->name || !desc->properties || !desc->num_properties)
1575 return ERR_PTR(error: -EINVAL);
1576
1577 if (!parent)
1578 pr_warn("%s: Expected proper parent device for '%s'\n",
1579 __func__, desc->name);
1580
1581 psy = kzalloc(sizeof(*psy), GFP_KERNEL);
1582 if (!psy)
1583 return ERR_PTR(error: -ENOMEM);
1584
1585 dev = &psy->dev;
1586
1587 device_initialize(dev);
1588
1589 dev->class = &power_supply_class;
1590 dev->type = &power_supply_dev_type;
1591 dev->parent = parent;
1592 dev->release = power_supply_dev_release;
1593 dev_set_drvdata(dev, data: psy);
1594 psy->desc = desc;
1595 if (cfg) {
1596 device_set_node(dev, fwnode: cfg->fwnode);
1597 dev->groups = cfg->attr_grp;
1598 psy->drv_data = cfg->drv_data;
1599 psy->supplied_to = cfg->supplied_to;
1600 psy->num_supplicants = cfg->num_supplicants;
1601 }
1602
1603 rc = dev_set_name(dev, name: "%s", desc->name);
1604 if (rc)
1605 goto dev_set_name_failed;
1606
1607 INIT_WORK(&psy->changed_work, power_supply_changed_work);
1608 INIT_DELAYED_WORK(&psy->deferred_register_work,
1609 power_supply_deferred_register_work);
1610
1611 rc = power_supply_check_supplies(psy);
1612 if (rc) {
1613 dev_dbg(dev, "Not all required supplies found, defer probe\n");
1614 goto check_supplies_failed;
1615 }
1616
1617 /*
1618 * Expose constant battery info, if it is available. While there are
1619 * some chargers accessing constant battery data, we only want to
1620 * expose battery data to userspace for battery devices.
1621 */
1622 if (desc->type == POWER_SUPPLY_TYPE_BATTERY) {
1623 rc = power_supply_get_battery_info(psy, &psy->battery_info);
1624 if (rc && rc != -ENODEV && rc != -ENOENT)
1625 goto check_supplies_failed;
1626 }
1627
1628 spin_lock_init(&psy->changed_lock);
1629 init_rwsem(&psy->extensions_sem);
1630 INIT_LIST_HEAD(list: &psy->extensions);
1631
1632 rc = device_add(dev);
1633 if (rc)
1634 goto device_add_failed;
1635
1636 rc = device_init_wakeup(dev, enable: cfg ? !cfg->no_wakeup_source : true);
1637 if (rc)
1638 goto wakeup_init_failed;
1639
1640 rc = psy_register_thermal(psy);
1641 if (rc)
1642 goto register_thermal_failed;
1643
1644 rc = power_supply_create_triggers(psy);
1645 if (rc)
1646 goto create_triggers_failed;
1647
1648 scoped_guard(rwsem_read, &psy->extensions_sem) {
1649 rc = power_supply_add_hwmon_sysfs(psy);
1650 if (rc)
1651 goto add_hwmon_sysfs_failed;
1652 }
1653
1654 /*
1655 * Update use_cnt after any uevents (most notably from device_add()).
1656 * We are here still during driver's probe but
1657 * the power_supply_uevent() calls back driver's get_property
1658 * method so:
1659 * 1. Driver did not assigned the returned struct power_supply,
1660 * 2. Driver could not finish initialization (anything in its probe
1661 * after calling power_supply_register()).
1662 */
1663 atomic_inc(v: &psy->use_cnt);
1664 psy->initialized = true;
1665
1666 queue_delayed_work(wq: system_power_efficient_wq,
1667 dwork: &psy->deferred_register_work,
1668 POWER_SUPPLY_DEFERRED_REGISTER_TIME);
1669
1670 return psy;
1671
1672add_hwmon_sysfs_failed:
1673 power_supply_remove_triggers(psy);
1674create_triggers_failed:
1675 psy_unregister_thermal(psy);
1676register_thermal_failed:
1677wakeup_init_failed:
1678 device_del(dev);
1679device_add_failed:
1680check_supplies_failed:
1681dev_set_name_failed:
1682 put_device(dev);
1683 return ERR_PTR(error: rc);
1684}
1685
1686/**
1687 * power_supply_register() - Register new power supply
1688 * @parent: Device to be a parent of power supply's device, usually
1689 * the device which probe function calls this
1690 * @desc: Description of power supply, must be valid through whole
1691 * lifetime of this power supply
1692 * @cfg: Run-time specific configuration accessed during registering,
1693 * may be NULL
1694 *
1695 * Return: A pointer to newly allocated power_supply on success
1696 * or ERR_PTR otherwise.
1697 * Use power_supply_unregister() on returned power_supply pointer to release
1698 * resources.
1699 */
1700struct power_supply *__must_check power_supply_register(struct device *parent,
1701 const struct power_supply_desc *desc,
1702 const struct power_supply_config *cfg)
1703{
1704 return __power_supply_register(parent, desc, cfg);
1705}
1706EXPORT_SYMBOL_GPL(power_supply_register);
1707
1708static void devm_power_supply_release(struct device *dev, void *res)
1709{
1710 struct power_supply **psy = res;
1711
1712 power_supply_unregister(psy: *psy);
1713}
1714
1715/**
1716 * devm_power_supply_register() - Register managed power supply
1717 * @parent: Device to be a parent of power supply's device, usually
1718 * the device which probe function calls this
1719 * @desc: Description of power supply, must be valid through whole
1720 * lifetime of this power supply
1721 * @cfg: Run-time specific configuration accessed during registering,
1722 * may be NULL
1723 *
1724 * Return: A pointer to newly allocated power_supply on success
1725 * or ERR_PTR otherwise.
1726 * The returned power_supply pointer will be automatically unregistered
1727 * on driver detach.
1728 */
1729struct power_supply *__must_check
1730devm_power_supply_register(struct device *parent,
1731 const struct power_supply_desc *desc,
1732 const struct power_supply_config *cfg)
1733{
1734 struct power_supply **ptr, *psy;
1735
1736 ptr = devres_alloc(devm_power_supply_release, sizeof(*ptr), GFP_KERNEL);
1737
1738 if (!ptr)
1739 return ERR_PTR(error: -ENOMEM);
1740 psy = __power_supply_register(parent, desc, cfg);
1741 if (IS_ERR(ptr: psy)) {
1742 devres_free(res: ptr);
1743 } else {
1744 *ptr = psy;
1745 devres_add(dev: parent, res: ptr);
1746 }
1747 return psy;
1748}
1749EXPORT_SYMBOL_GPL(devm_power_supply_register);
1750
1751/**
1752 * power_supply_unregister() - Remove this power supply from system
1753 * @psy: Pointer to power supply to unregister
1754 *
1755 * Remove this power supply from the system. The resources of power supply
1756 * will be freed here or on last power_supply_put() call.
1757 */
1758void power_supply_unregister(struct power_supply *psy)
1759{
1760 WARN_ON(atomic_dec_return(&psy->use_cnt));
1761 psy->removing = true;
1762 cancel_work_sync(work: &psy->changed_work);
1763 cancel_delayed_work_sync(dwork: &psy->deferred_register_work);
1764 sysfs_remove_link(kobj: &psy->dev.kobj, name: "powers");
1765 power_supply_remove_hwmon_sysfs(psy);
1766 power_supply_remove_triggers(psy);
1767 psy_unregister_thermal(psy);
1768 device_init_wakeup(dev: &psy->dev, enable: false);
1769 device_unregister(dev: &psy->dev);
1770}
1771EXPORT_SYMBOL_GPL(power_supply_unregister);
1772
1773void *power_supply_get_drvdata(struct power_supply *psy)
1774{
1775 return psy->drv_data;
1776}
1777EXPORT_SYMBOL_GPL(power_supply_get_drvdata);
1778
1779static int __init power_supply_class_init(void)
1780{
1781 power_supply_init_attrs();
1782 return class_register(class: &power_supply_class);
1783}
1784
1785static void __exit power_supply_class_exit(void)
1786{
1787 class_unregister(class: &power_supply_class);
1788}
1789
1790subsys_initcall(power_supply_class_init);
1791module_exit(power_supply_class_exit);
1792
1793MODULE_DESCRIPTION("Universal power supply monitor class");
1794MODULE_AUTHOR("Ian Molton <spyro@f2s.com>");
1795MODULE_AUTHOR("Szabolcs Gyurko");
1796MODULE_AUTHOR("Anton Vorontsov <cbou@mail.ru>");
1797