LCOV - code coverage report
Current view: top level - drivers/power/supply - power_supply_core.c (source / functions) Hit Total Coverage
Test: combined.info Lines: 6 412 1.5 %
Date: 2022-03-28 16:04:14 Functions: 1 46 2.2 %
Branches: 1 222 0.5 %

           Branch data     Line data    Source code
       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/module.h>
      13                 :            : #include <linux/types.h>
      14                 :            : #include <linux/init.h>
      15                 :            : #include <linux/slab.h>
      16                 :            : #include <linux/delay.h>
      17                 :            : #include <linux/device.h>
      18                 :            : #include <linux/notifier.h>
      19                 :            : #include <linux/err.h>
      20                 :            : #include <linux/of.h>
      21                 :            : #include <linux/power_supply.h>
      22                 :            : #include <linux/property.h>
      23                 :            : #include <linux/thermal.h>
      24                 :            : #include "power_supply.h"
      25                 :            : 
      26                 :            : /* exported for the APM Power driver, APM emulation */
      27                 :            : struct class *power_supply_class;
      28                 :            : EXPORT_SYMBOL_GPL(power_supply_class);
      29                 :            : 
      30                 :            : ATOMIC_NOTIFIER_HEAD(power_supply_notifier);
      31                 :            : EXPORT_SYMBOL_GPL(power_supply_notifier);
      32                 :            : 
      33                 :            : static struct device_type power_supply_dev_type;
      34                 :            : 
      35                 :            : #define POWER_SUPPLY_DEFERRED_REGISTER_TIME     msecs_to_jiffies(10)
      36                 :            : 
      37                 :          0 : static bool __power_supply_is_supplied_by(struct power_supply *supplier,
      38                 :            :                                          struct power_supply *supply)
      39                 :            : {
      40                 :          0 :         int i;
      41                 :            : 
      42   [ #  #  #  # ]:          0 :         if (!supply->supplied_from && !supplier->supplied_to)
      43                 :            :                 return false;
      44                 :            : 
      45                 :            :         /* Support both supplied_to and supplied_from modes */
      46         [ #  # ]:          0 :         if (supply->supplied_from) {
      47         [ #  # ]:          0 :                 if (!supplier->desc->name)
      48                 :            :                         return false;
      49         [ #  # ]:          0 :                 for (i = 0; i < supply->num_supplies; i++)
      50         [ #  # ]:          0 :                         if (!strcmp(supplier->desc->name, supply->supplied_from[i]))
      51                 :            :                                 return true;
      52                 :            :         } else {
      53         [ #  # ]:          0 :                 if (!supply->desc->name)
      54                 :            :                         return false;
      55         [ #  # ]:          0 :                 for (i = 0; i < supplier->num_supplicants; i++)
      56         [ #  # ]:          0 :                         if (!strcmp(supplier->supplied_to[i], supply->desc->name))
      57                 :            :                                 return true;
      58                 :            :         }
      59                 :            : 
      60                 :            :         return false;
      61                 :            : }
      62                 :            : 
      63                 :          0 : static int __power_supply_changed_work(struct device *dev, void *data)
      64                 :            : {
      65                 :          0 :         struct power_supply *psy = data;
      66                 :          0 :         struct power_supply *pst = dev_get_drvdata(dev);
      67                 :            : 
      68         [ #  # ]:          0 :         if (__power_supply_is_supplied_by(psy, pst)) {
      69         [ #  # ]:          0 :                 if (pst->desc->external_power_changed)
      70                 :          0 :                         pst->desc->external_power_changed(pst);
      71                 :            :         }
      72                 :            : 
      73                 :          0 :         return 0;
      74                 :            : }
      75                 :            : 
      76                 :          0 : static void power_supply_changed_work(struct work_struct *work)
      77                 :            : {
      78                 :          0 :         unsigned long flags;
      79                 :          0 :         struct power_supply *psy = container_of(work, struct power_supply,
      80                 :            :                                                 changed_work);
      81                 :            : 
      82                 :          0 :         dev_dbg(&psy->dev, "%s\n", __func__);
      83                 :            : 
      84                 :          0 :         spin_lock_irqsave(&psy->changed_lock, flags);
      85                 :            :         /*
      86                 :            :          * Check 'changed' here to avoid issues due to race between
      87                 :            :          * power_supply_changed() and this routine. In worst case
      88                 :            :          * power_supply_changed() can be called again just before we take above
      89                 :            :          * lock. During the first call of this routine we will mark 'changed' as
      90                 :            :          * false and it will stay false for the next call as well.
      91                 :            :          */
      92         [ #  # ]:          0 :         if (likely(psy->changed)) {
      93                 :          0 :                 psy->changed = false;
      94                 :          0 :                 spin_unlock_irqrestore(&psy->changed_lock, flags);
      95                 :          0 :                 class_for_each_device(power_supply_class, NULL, psy,
      96                 :            :                                       __power_supply_changed_work);
      97                 :          0 :                 power_supply_update_leds(psy);
      98                 :          0 :                 atomic_notifier_call_chain(&power_supply_notifier,
      99                 :            :                                 PSY_EVENT_PROP_CHANGED, psy);
     100                 :          0 :                 kobject_uevent(&psy->dev.kobj, KOBJ_CHANGE);
     101                 :          0 :                 spin_lock_irqsave(&psy->changed_lock, flags);
     102                 :            :         }
     103                 :            : 
     104                 :            :         /*
     105                 :            :          * Hold the wakeup_source until all events are processed.
     106                 :            :          * power_supply_changed() might have called again and have set 'changed'
     107                 :            :          * to true.
     108                 :            :          */
     109         [ #  # ]:          0 :         if (likely(!psy->changed))
     110                 :          0 :                 pm_relax(&psy->dev);
     111                 :          0 :         spin_unlock_irqrestore(&psy->changed_lock, flags);
     112                 :          0 : }
     113                 :            : 
     114                 :          0 : void power_supply_changed(struct power_supply *psy)
     115                 :            : {
     116                 :          0 :         unsigned long flags;
     117                 :            : 
     118                 :          0 :         dev_dbg(&psy->dev, "%s\n", __func__);
     119                 :            : 
     120                 :          0 :         spin_lock_irqsave(&psy->changed_lock, flags);
     121                 :          0 :         psy->changed = true;
     122                 :          0 :         pm_stay_awake(&psy->dev);
     123                 :          0 :         spin_unlock_irqrestore(&psy->changed_lock, flags);
     124                 :          0 :         schedule_work(&psy->changed_work);
     125                 :          0 : }
     126                 :            : EXPORT_SYMBOL_GPL(power_supply_changed);
     127                 :            : 
     128                 :            : /*
     129                 :            :  * Notify that power supply was registered after parent finished the probing.
     130                 :            :  *
     131                 :            :  * Often power supply is registered from driver's probe function. However
     132                 :            :  * calling power_supply_changed() directly from power_supply_register()
     133                 :            :  * would lead to execution of get_property() function provided by the driver
     134                 :            :  * too early - before the probe ends.
     135                 :            :  *
     136                 :            :  * Avoid that by waiting on parent's mutex.
     137                 :            :  */
     138                 :          0 : static void power_supply_deferred_register_work(struct work_struct *work)
     139                 :            : {
     140                 :          0 :         struct power_supply *psy = container_of(work, struct power_supply,
     141                 :            :                                                 deferred_register_work.work);
     142                 :            : 
     143         [ #  # ]:          0 :         if (psy->dev.parent) {
     144         [ #  # ]:          0 :                 while (!mutex_trylock(&psy->dev.parent->mutex)) {
     145         [ #  # ]:          0 :                         if (psy->removing)
     146                 :            :                                 return;
     147                 :          0 :                         msleep(10);
     148                 :            :                 }
     149                 :            :         }
     150                 :            : 
     151                 :          0 :         power_supply_changed(psy);
     152                 :            : 
     153         [ #  # ]:          0 :         if (psy->dev.parent)
     154                 :          0 :                 mutex_unlock(&psy->dev.parent->mutex);
     155                 :            : }
     156                 :            : 
     157                 :            : #ifdef CONFIG_OF
     158                 :            : static int __power_supply_populate_supplied_from(struct device *dev,
     159                 :            :                                                  void *data)
     160                 :            : {
     161                 :            :         struct power_supply *psy = data;
     162                 :            :         struct power_supply *epsy = dev_get_drvdata(dev);
     163                 :            :         struct device_node *np;
     164                 :            :         int i = 0;
     165                 :            : 
     166                 :            :         do {
     167                 :            :                 np = of_parse_phandle(psy->of_node, "power-supplies", i++);
     168                 :            :                 if (!np)
     169                 :            :                         break;
     170                 :            : 
     171                 :            :                 if (np == epsy->of_node) {
     172                 :            :                         dev_info(&psy->dev, "%s: Found supply : %s\n",
     173                 :            :                                 psy->desc->name, epsy->desc->name);
     174                 :            :                         psy->supplied_from[i-1] = (char *)epsy->desc->name;
     175                 :            :                         psy->num_supplies++;
     176                 :            :                         of_node_put(np);
     177                 :            :                         break;
     178                 :            :                 }
     179                 :            :                 of_node_put(np);
     180                 :            :         } while (np);
     181                 :            : 
     182                 :            :         return 0;
     183                 :            : }
     184                 :            : 
     185                 :            : static int power_supply_populate_supplied_from(struct power_supply *psy)
     186                 :            : {
     187                 :            :         int error;
     188                 :            : 
     189                 :            :         error = class_for_each_device(power_supply_class, NULL, psy,
     190                 :            :                                       __power_supply_populate_supplied_from);
     191                 :            : 
     192                 :            :         dev_dbg(&psy->dev, "%s %d\n", __func__, error);
     193                 :            : 
     194                 :            :         return error;
     195                 :            : }
     196                 :            : 
     197                 :            : static int  __power_supply_find_supply_from_node(struct device *dev,
     198                 :            :                                                  void *data)
     199                 :            : {
     200                 :            :         struct device_node *np = data;
     201                 :            :         struct power_supply *epsy = dev_get_drvdata(dev);
     202                 :            : 
     203                 :            :         /* returning non-zero breaks out of class_for_each_device loop */
     204                 :            :         if (epsy->of_node == np)
     205                 :            :                 return 1;
     206                 :            : 
     207                 :            :         return 0;
     208                 :            : }
     209                 :            : 
     210                 :            : static int power_supply_find_supply_from_node(struct device_node *supply_node)
     211                 :            : {
     212                 :            :         int error;
     213                 :            : 
     214                 :            :         /*
     215                 :            :          * class_for_each_device() either returns its own errors or values
     216                 :            :          * returned by __power_supply_find_supply_from_node().
     217                 :            :          *
     218                 :            :          * __power_supply_find_supply_from_node() will return 0 (no match)
     219                 :            :          * or 1 (match).
     220                 :            :          *
     221                 :            :          * We return 0 if class_for_each_device() returned 1, -EPROBE_DEFER if
     222                 :            :          * it returned 0, or error as returned by it.
     223                 :            :          */
     224                 :            :         error = class_for_each_device(power_supply_class, NULL, supply_node,
     225                 :            :                                        __power_supply_find_supply_from_node);
     226                 :            : 
     227                 :            :         return error ? (error == 1 ? 0 : error) : -EPROBE_DEFER;
     228                 :            : }
     229                 :            : 
     230                 :            : static int power_supply_check_supplies(struct power_supply *psy)
     231                 :            : {
     232                 :            :         struct device_node *np;
     233                 :            :         int cnt = 0;
     234                 :            : 
     235                 :            :         /* If there is already a list honor it */
     236                 :            :         if (psy->supplied_from && psy->num_supplies > 0)
     237                 :            :                 return 0;
     238                 :            : 
     239                 :            :         /* No device node found, nothing to do */
     240                 :            :         if (!psy->of_node)
     241                 :            :                 return 0;
     242                 :            : 
     243                 :            :         do {
     244                 :            :                 int ret;
     245                 :            : 
     246                 :            :                 np = of_parse_phandle(psy->of_node, "power-supplies", cnt++);
     247                 :            :                 if (!np)
     248                 :            :                         break;
     249                 :            : 
     250                 :            :                 ret = power_supply_find_supply_from_node(np);
     251                 :            :                 of_node_put(np);
     252                 :            : 
     253                 :            :                 if (ret) {
     254                 :            :                         dev_dbg(&psy->dev, "Failed to find supply!\n");
     255                 :            :                         return ret;
     256                 :            :                 }
     257                 :            :         } while (np);
     258                 :            : 
     259                 :            :         /* Missing valid "power-supplies" entries */
     260                 :            :         if (cnt == 1)
     261                 :            :                 return 0;
     262                 :            : 
     263                 :            :         /* All supplies found, allocate char ** array for filling */
     264                 :            :         psy->supplied_from = devm_kzalloc(&psy->dev, sizeof(psy->supplied_from),
     265                 :            :                                           GFP_KERNEL);
     266                 :            :         if (!psy->supplied_from)
     267                 :            :                 return -ENOMEM;
     268                 :            : 
     269                 :            :         *psy->supplied_from = devm_kcalloc(&psy->dev,
     270                 :            :                                            cnt - 1, sizeof(char *),
     271                 :            :                                            GFP_KERNEL);
     272                 :            :         if (!*psy->supplied_from)
     273                 :            :                 return -ENOMEM;
     274                 :            : 
     275                 :            :         return power_supply_populate_supplied_from(psy);
     276                 :            : }
     277                 :            : #else
     278                 :          0 : static int power_supply_check_supplies(struct power_supply *psy)
     279                 :            : {
     280                 :          0 :         int nval, ret;
     281                 :            : 
     282         [ #  # ]:          0 :         if (!psy->dev.parent)
     283                 :            :                 return 0;
     284                 :            : 
     285                 :          0 :         nval = device_property_read_string_array(psy->dev.parent,
     286                 :            :                                                  "supplied-from", NULL, 0);
     287         [ #  # ]:          0 :         if (nval <= 0)
     288                 :            :                 return 0;
     289                 :            : 
     290                 :          0 :         psy->supplied_from = devm_kmalloc_array(&psy->dev, nval,
     291                 :            :                                                 sizeof(char *), GFP_KERNEL);
     292         [ #  # ]:          0 :         if (!psy->supplied_from)
     293                 :            :                 return -ENOMEM;
     294                 :            : 
     295                 :          0 :         ret = device_property_read_string_array(psy->dev.parent,
     296                 :            :                 "supplied-from", (const char **)psy->supplied_from, nval);
     297         [ #  # ]:          0 :         if (ret < 0)
     298                 :            :                 return ret;
     299                 :            : 
     300                 :          0 :         psy->num_supplies = nval;
     301                 :            : 
     302                 :          0 :         return 0;
     303                 :            : }
     304                 :            : #endif
     305                 :            : 
     306                 :            : struct psy_am_i_supplied_data {
     307                 :            :         struct power_supply *psy;
     308                 :            :         unsigned int count;
     309                 :            : };
     310                 :            : 
     311                 :          0 : static int __power_supply_am_i_supplied(struct device *dev, void *_data)
     312                 :            : {
     313                 :          0 :         union power_supply_propval ret = {0,};
     314                 :          0 :         struct power_supply *epsy = dev_get_drvdata(dev);
     315                 :          0 :         struct psy_am_i_supplied_data *data = _data;
     316                 :            : 
     317         [ #  # ]:          0 :         if (__power_supply_is_supplied_by(epsy, data->psy)) {
     318                 :          0 :                 data->count++;
     319         [ #  # ]:          0 :                 if (!epsy->desc->get_property(epsy, POWER_SUPPLY_PROP_ONLINE,
     320                 :            :                                         &ret))
     321                 :          0 :                         return ret.intval;
     322                 :            :         }
     323                 :            : 
     324                 :            :         return 0;
     325                 :            : }
     326                 :            : 
     327                 :          0 : int power_supply_am_i_supplied(struct power_supply *psy)
     328                 :            : {
     329                 :          0 :         struct psy_am_i_supplied_data data = { psy, 0 };
     330                 :          0 :         int error;
     331                 :            : 
     332                 :          0 :         error = class_for_each_device(power_supply_class, NULL, &data,
     333                 :            :                                       __power_supply_am_i_supplied);
     334                 :            : 
     335                 :          0 :         dev_dbg(&psy->dev, "%s count %u err %d\n", __func__, data.count, error);
     336                 :            : 
     337         [ #  # ]:          0 :         if (data.count == 0)
     338                 :          0 :                 return -ENODEV;
     339                 :            : 
     340                 :            :         return error;
     341                 :            : }
     342                 :            : EXPORT_SYMBOL_GPL(power_supply_am_i_supplied);
     343                 :            : 
     344                 :          0 : static int __power_supply_is_system_supplied(struct device *dev, void *data)
     345                 :            : {
     346                 :          0 :         union power_supply_propval ret = {0,};
     347         [ #  # ]:          0 :         struct power_supply *psy = dev_get_drvdata(dev);
     348                 :          0 :         unsigned int *count = data;
     349                 :            : 
     350                 :          0 :         (*count)++;
     351         [ #  # ]:          0 :         if (psy->desc->type != POWER_SUPPLY_TYPE_BATTERY)
     352         [ #  # ]:          0 :                 if (!psy->desc->get_property(psy, POWER_SUPPLY_PROP_ONLINE,
     353                 :            :                                         &ret))
     354                 :          0 :                         return ret.intval;
     355                 :            : 
     356                 :            :         return 0;
     357                 :            : }
     358                 :            : 
     359                 :          0 : int power_supply_is_system_supplied(void)
     360                 :            : {
     361                 :          0 :         int error;
     362                 :          0 :         unsigned int count = 0;
     363                 :            : 
     364                 :          0 :         error = class_for_each_device(power_supply_class, NULL, &count,
     365                 :            :                                       __power_supply_is_system_supplied);
     366                 :            : 
     367                 :            :         /*
     368                 :            :          * If no power class device was found at all, most probably we are
     369                 :            :          * running on a desktop system, so assume we are on mains power.
     370                 :            :          */
     371         [ #  # ]:          0 :         if (count == 0)
     372                 :          0 :                 return 1;
     373                 :            : 
     374                 :            :         return error;
     375                 :            : }
     376                 :            : EXPORT_SYMBOL_GPL(power_supply_is_system_supplied);
     377                 :            : 
     378                 :          0 : static int __power_supply_get_supplier_max_current(struct device *dev,
     379                 :            :                                                    void *data)
     380                 :            : {
     381                 :          0 :         union power_supply_propval ret = {0,};
     382                 :          0 :         struct power_supply *epsy = dev_get_drvdata(dev);
     383                 :          0 :         struct power_supply *psy = data;
     384                 :            : 
     385         [ #  # ]:          0 :         if (__power_supply_is_supplied_by(epsy, psy))
     386         [ #  # ]:          0 :                 if (!epsy->desc->get_property(epsy,
     387                 :            :                                               POWER_SUPPLY_PROP_CURRENT_MAX,
     388                 :            :                                               &ret))
     389                 :          0 :                         return ret.intval;
     390                 :            : 
     391                 :            :         return 0;
     392                 :            : }
     393                 :            : 
     394                 :          0 : int power_supply_set_input_current_limit_from_supplier(struct power_supply *psy)
     395                 :            : {
     396                 :          0 :         union power_supply_propval val = {0,};
     397                 :          0 :         int curr;
     398                 :            : 
     399         [ #  # ]:          0 :         if (!psy->desc->set_property)
     400                 :            :                 return -EINVAL;
     401                 :            : 
     402                 :            :         /*
     403                 :            :          * This function is not intended for use with a supply with multiple
     404                 :            :          * suppliers, we simply pick the first supply to report a non 0
     405                 :            :          * max-current.
     406                 :            :          */
     407                 :          0 :         curr = class_for_each_device(power_supply_class, NULL, psy,
     408                 :            :                                       __power_supply_get_supplier_max_current);
     409         [ #  # ]:          0 :         if (curr <= 0)
     410         [ #  # ]:          0 :                 return (curr == 0) ? -ENODEV : curr;
     411                 :            : 
     412                 :          0 :         val.intval = curr;
     413                 :            : 
     414                 :          0 :         return psy->desc->set_property(psy,
     415                 :            :                                 POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT, &val);
     416                 :            : }
     417                 :            : EXPORT_SYMBOL_GPL(power_supply_set_input_current_limit_from_supplier);
     418                 :            : 
     419                 :          0 : int power_supply_set_battery_charged(struct power_supply *psy)
     420                 :            : {
     421         [ #  # ]:          0 :         if (atomic_read(&psy->use_cnt) >= 0 &&
     422         [ #  # ]:          0 :                         psy->desc->type == POWER_SUPPLY_TYPE_BATTERY &&
     423         [ #  # ]:          0 :                         psy->desc->set_charged) {
     424                 :          0 :                 psy->desc->set_charged(psy);
     425                 :          0 :                 return 0;
     426                 :            :         }
     427                 :            : 
     428                 :            :         return -EINVAL;
     429                 :            : }
     430                 :            : EXPORT_SYMBOL_GPL(power_supply_set_battery_charged);
     431                 :            : 
     432                 :          0 : static int power_supply_match_device_by_name(struct device *dev, const void *data)
     433                 :            : {
     434                 :          0 :         const char *name = data;
     435                 :          0 :         struct power_supply *psy = dev_get_drvdata(dev);
     436                 :            : 
     437                 :          0 :         return strcmp(psy->desc->name, name) == 0;
     438                 :            : }
     439                 :            : 
     440                 :            : /**
     441                 :            :  * power_supply_get_by_name() - Search for a power supply and returns its ref
     442                 :            :  * @name: Power supply name to fetch
     443                 :            :  *
     444                 :            :  * If power supply was found, it increases reference count for the
     445                 :            :  * internal power supply's device. The user should power_supply_put()
     446                 :            :  * after usage.
     447                 :            :  *
     448                 :            :  * Return: On success returns a reference to a power supply with
     449                 :            :  * matching name equals to @name, a NULL otherwise.
     450                 :            :  */
     451                 :          0 : struct power_supply *power_supply_get_by_name(const char *name)
     452                 :            : {
     453                 :          0 :         struct power_supply *psy = NULL;
     454                 :          0 :         struct device *dev = class_find_device(power_supply_class, NULL, name,
     455                 :            :                                         power_supply_match_device_by_name);
     456                 :            : 
     457         [ #  # ]:          0 :         if (dev) {
     458                 :          0 :                 psy = dev_get_drvdata(dev);
     459                 :          0 :                 atomic_inc(&psy->use_cnt);
     460                 :            :         }
     461                 :            : 
     462                 :          0 :         return psy;
     463                 :            : }
     464                 :            : EXPORT_SYMBOL_GPL(power_supply_get_by_name);
     465                 :            : 
     466                 :            : /**
     467                 :            :  * power_supply_put() - Drop reference obtained with power_supply_get_by_name
     468                 :            :  * @psy: Reference to put
     469                 :            :  *
     470                 :            :  * The reference to power supply should be put before unregistering
     471                 :            :  * the power supply.
     472                 :            :  */
     473                 :          0 : void power_supply_put(struct power_supply *psy)
     474                 :            : {
     475                 :          0 :         might_sleep();
     476                 :            : 
     477                 :          0 :         atomic_dec(&psy->use_cnt);
     478                 :          0 :         put_device(&psy->dev);
     479                 :          0 : }
     480                 :            : EXPORT_SYMBOL_GPL(power_supply_put);
     481                 :            : 
     482                 :            : #ifdef CONFIG_OF
     483                 :            : static int power_supply_match_device_node(struct device *dev, const void *data)
     484                 :            : {
     485                 :            :         return dev->parent && dev->parent->of_node == data;
     486                 :            : }
     487                 :            : 
     488                 :            : /**
     489                 :            :  * power_supply_get_by_phandle() - Search for a power supply and returns its ref
     490                 :            :  * @np: Pointer to device node holding phandle property
     491                 :            :  * @property: Name of property holding a power supply name
     492                 :            :  *
     493                 :            :  * If power supply was found, it increases reference count for the
     494                 :            :  * internal power supply's device. The user should power_supply_put()
     495                 :            :  * after usage.
     496                 :            :  *
     497                 :            :  * Return: On success returns a reference to a power supply with
     498                 :            :  * matching name equals to value under @property, NULL or ERR_PTR otherwise.
     499                 :            :  */
     500                 :            : struct power_supply *power_supply_get_by_phandle(struct device_node *np,
     501                 :            :                                                         const char *property)
     502                 :            : {
     503                 :            :         struct device_node *power_supply_np;
     504                 :            :         struct power_supply *psy = NULL;
     505                 :            :         struct device *dev;
     506                 :            : 
     507                 :            :         power_supply_np = of_parse_phandle(np, property, 0);
     508                 :            :         if (!power_supply_np)
     509                 :            :                 return ERR_PTR(-ENODEV);
     510                 :            : 
     511                 :            :         dev = class_find_device(power_supply_class, NULL, power_supply_np,
     512                 :            :                                                 power_supply_match_device_node);
     513                 :            : 
     514                 :            :         of_node_put(power_supply_np);
     515                 :            : 
     516                 :            :         if (dev) {
     517                 :            :                 psy = dev_get_drvdata(dev);
     518                 :            :                 atomic_inc(&psy->use_cnt);
     519                 :            :         }
     520                 :            : 
     521                 :            :         return psy;
     522                 :            : }
     523                 :            : EXPORT_SYMBOL_GPL(power_supply_get_by_phandle);
     524                 :            : 
     525                 :            : static void devm_power_supply_put(struct device *dev, void *res)
     526                 :            : {
     527                 :            :         struct power_supply **psy = res;
     528                 :            : 
     529                 :            :         power_supply_put(*psy);
     530                 :            : }
     531                 :            : 
     532                 :            : /**
     533                 :            :  * devm_power_supply_get_by_phandle() - Resource managed version of
     534                 :            :  *  power_supply_get_by_phandle()
     535                 :            :  * @dev: Pointer to device holding phandle property
     536                 :            :  * @property: Name of property holding a power supply phandle
     537                 :            :  *
     538                 :            :  * Return: On success returns a reference to a power supply with
     539                 :            :  * matching name equals to value under @property, NULL or ERR_PTR otherwise.
     540                 :            :  */
     541                 :            : struct power_supply *devm_power_supply_get_by_phandle(struct device *dev,
     542                 :            :                                                       const char *property)
     543                 :            : {
     544                 :            :         struct power_supply **ptr, *psy;
     545                 :            : 
     546                 :            :         if (!dev->of_node)
     547                 :            :                 return ERR_PTR(-ENODEV);
     548                 :            : 
     549                 :            :         ptr = devres_alloc(devm_power_supply_put, sizeof(*ptr), GFP_KERNEL);
     550                 :            :         if (!ptr)
     551                 :            :                 return ERR_PTR(-ENOMEM);
     552                 :            : 
     553                 :            :         psy = power_supply_get_by_phandle(dev->of_node, property);
     554                 :            :         if (IS_ERR_OR_NULL(psy)) {
     555                 :            :                 devres_free(ptr);
     556                 :            :         } else {
     557                 :            :                 *ptr = psy;
     558                 :            :                 devres_add(dev, ptr);
     559                 :            :         }
     560                 :            :         return psy;
     561                 :            : }
     562                 :            : EXPORT_SYMBOL_GPL(devm_power_supply_get_by_phandle);
     563                 :            : #endif /* CONFIG_OF */
     564                 :            : 
     565                 :          0 : int power_supply_get_battery_info(struct power_supply *psy,
     566                 :            :                                   struct power_supply_battery_info *info)
     567                 :            : {
     568                 :          0 :         struct power_supply_resistance_temp_table *resist_table;
     569                 :          0 :         struct device_node *battery_np;
     570                 :          0 :         const char *value;
     571                 :          0 :         int err, len, index;
     572                 :          0 :         const __be32 *list;
     573                 :            : 
     574                 :          0 :         info->energy_full_design_uwh         = -EINVAL;
     575                 :          0 :         info->charge_full_design_uah         = -EINVAL;
     576                 :          0 :         info->voltage_min_design_uv          = -EINVAL;
     577                 :          0 :         info->voltage_max_design_uv          = -EINVAL;
     578                 :          0 :         info->precharge_current_ua           = -EINVAL;
     579                 :          0 :         info->charge_term_current_ua         = -EINVAL;
     580                 :          0 :         info->constant_charge_current_max_ua = -EINVAL;
     581                 :          0 :         info->constant_charge_voltage_max_uv = -EINVAL;
     582                 :          0 :         info->factory_internal_resistance_uohm  = -EINVAL;
     583                 :          0 :         info->resist_table = NULL;
     584                 :            : 
     585         [ #  # ]:          0 :         for (index = 0; index < POWER_SUPPLY_OCV_TEMP_MAX; index++) {
     586                 :          0 :                 info->ocv_table[index]       = NULL;
     587                 :          0 :                 info->ocv_temp[index]        = -EINVAL;
     588                 :          0 :                 info->ocv_table_size[index]  = -EINVAL;
     589                 :            :         }
     590                 :            : 
     591         [ #  # ]:          0 :         if (!psy->of_node) {
     592                 :          0 :                 dev_warn(&psy->dev, "%s currently only supports devicetree\n",
     593                 :            :                          __func__);
     594                 :          0 :                 return -ENXIO;
     595                 :            :         }
     596                 :            : 
     597                 :            :         battery_np = of_parse_phandle(psy->of_node, "monitored-battery", 0);
     598                 :            :         if (!battery_np)
     599                 :            :                 return -ENODEV;
     600                 :            : 
     601                 :            :         err = of_property_read_string(battery_np, "compatible", &value);
     602                 :            :         if (err)
     603                 :            :                 goto out_put_node;
     604                 :            : 
     605                 :            :         if (strcmp("simple-battery", value)) {
     606                 :            :                 err = -ENODEV;
     607                 :            :                 goto out_put_node;
     608                 :            :         }
     609                 :            : 
     610                 :            :         /* The property and field names below must correspond to elements
     611                 :            :          * in enum power_supply_property. For reasoning, see
     612                 :            :          * Documentation/power/power_supply_class.rst.
     613                 :            :          */
     614                 :            : 
     615                 :            :         of_property_read_u32(battery_np, "energy-full-design-microwatt-hours",
     616                 :            :                              &info->energy_full_design_uwh);
     617                 :            :         of_property_read_u32(battery_np, "charge-full-design-microamp-hours",
     618                 :            :                              &info->charge_full_design_uah);
     619                 :            :         of_property_read_u32(battery_np, "voltage-min-design-microvolt",
     620                 :            :                              &info->voltage_min_design_uv);
     621                 :            :         of_property_read_u32(battery_np, "voltage-max-design-microvolt",
     622                 :            :                              &info->voltage_max_design_uv);
     623                 :            :         of_property_read_u32(battery_np, "precharge-current-microamp",
     624                 :            :                              &info->precharge_current_ua);
     625                 :            :         of_property_read_u32(battery_np, "charge-term-current-microamp",
     626                 :            :                              &info->charge_term_current_ua);
     627                 :            :         of_property_read_u32(battery_np, "constant-charge-current-max-microamp",
     628                 :            :                              &info->constant_charge_current_max_ua);
     629                 :            :         of_property_read_u32(battery_np, "constant-charge-voltage-max-microvolt",
     630                 :            :                              &info->constant_charge_voltage_max_uv);
     631                 :            :         of_property_read_u32(battery_np, "factory-internal-resistance-micro-ohms",
     632                 :            :                              &info->factory_internal_resistance_uohm);
     633                 :            : 
     634                 :            :         len = of_property_count_u32_elems(battery_np, "ocv-capacity-celsius");
     635                 :            :         if (len < 0 && len != -EINVAL) {
     636                 :            :                 err = len;
     637                 :            :                 goto out_put_node;
     638                 :            :         } else if (len > POWER_SUPPLY_OCV_TEMP_MAX) {
     639                 :            :                 dev_err(&psy->dev, "Too many temperature values\n");
     640                 :            :                 err = -EINVAL;
     641                 :            :                 goto out_put_node;
     642                 :            :         } else if (len > 0) {
     643                 :            :                 of_property_read_u32_array(battery_np, "ocv-capacity-celsius",
     644                 :            :                                            info->ocv_temp, len);
     645                 :            :         }
     646                 :            : 
     647                 :            :         for (index = 0; index < len; index++) {
     648                 :            :                 struct power_supply_battery_ocv_table *table;
     649                 :            :                 char *propname;
     650                 :            :                 int i, tab_len, size;
     651                 :            : 
     652                 :            :                 propname = kasprintf(GFP_KERNEL, "ocv-capacity-table-%d", index);
     653                 :            :                 list = of_get_property(battery_np, propname, &size);
     654                 :            :                 if (!list || !size) {
     655                 :            :                         dev_err(&psy->dev, "failed to get %s\n", propname);
     656                 :            :                         kfree(propname);
     657                 :            :                         power_supply_put_battery_info(psy, info);
     658                 :            :                         err = -EINVAL;
     659                 :            :                         goto out_put_node;
     660                 :            :                 }
     661                 :            : 
     662                 :            :                 kfree(propname);
     663                 :            :                 tab_len = size / (2 * sizeof(__be32));
     664                 :            :                 info->ocv_table_size[index] = tab_len;
     665                 :            : 
     666                 :            :                 table = info->ocv_table[index] =
     667                 :            :                         devm_kcalloc(&psy->dev, tab_len, sizeof(*table), GFP_KERNEL);
     668                 :            :                 if (!info->ocv_table[index]) {
     669                 :            :                         power_supply_put_battery_info(psy, info);
     670                 :            :                         err = -ENOMEM;
     671                 :            :                         goto out_put_node;
     672                 :            :                 }
     673                 :            : 
     674                 :            :                 for (i = 0; i < tab_len; i++) {
     675                 :            :                         table[i].ocv = be32_to_cpu(*list);
     676                 :            :                         list++;
     677                 :            :                         table[i].capacity = be32_to_cpu(*list);
     678                 :            :                         list++;
     679                 :            :                 }
     680                 :            :         }
     681                 :            : 
     682                 :            :         list = of_get_property(battery_np, "resistance-temp-table", &len);
     683                 :            :         if (!list || !len)
     684                 :            :                 goto out_put_node;
     685                 :            : 
     686                 :            :         info->resist_table_size = len / (2 * sizeof(__be32));
     687                 :            :         resist_table = info->resist_table = devm_kcalloc(&psy->dev,
     688                 :            :                                                          info->resist_table_size,
     689                 :            :                                                          sizeof(*resist_table),
     690                 :            :                                                          GFP_KERNEL);
     691                 :            :         if (!info->resist_table) {
     692                 :            :                 power_supply_put_battery_info(psy, info);
     693                 :            :                 err = -ENOMEM;
     694                 :            :                 goto out_put_node;
     695                 :            :         }
     696                 :            : 
     697                 :            :         for (index = 0; index < info->resist_table_size; index++) {
     698                 :            :                 resist_table[index].temp = be32_to_cpu(*list++);
     699                 :            :                 resist_table[index].resistance = be32_to_cpu(*list++);
     700                 :            :         }
     701                 :            : 
     702                 :            : out_put_node:
     703                 :            :         of_node_put(battery_np);
     704                 :            :         return err;
     705                 :            : }
     706                 :            : EXPORT_SYMBOL_GPL(power_supply_get_battery_info);
     707                 :            : 
     708                 :          0 : void power_supply_put_battery_info(struct power_supply *psy,
     709                 :            :                                    struct power_supply_battery_info *info)
     710                 :            : {
     711                 :          0 :         int i;
     712                 :            : 
     713         [ #  # ]:          0 :         for (i = 0; i < POWER_SUPPLY_OCV_TEMP_MAX; i++) {
     714         [ #  # ]:          0 :                 if (info->ocv_table[i])
     715                 :          0 :                         devm_kfree(&psy->dev, info->ocv_table[i]);
     716                 :            :         }
     717                 :            : 
     718         [ #  # ]:          0 :         if (info->resist_table)
     719                 :          0 :                 devm_kfree(&psy->dev, info->resist_table);
     720                 :          0 : }
     721                 :            : EXPORT_SYMBOL_GPL(power_supply_put_battery_info);
     722                 :            : 
     723                 :            : /**
     724                 :            :  * power_supply_temp2resist_simple() - find the battery internal resistance
     725                 :            :  * percent
     726                 :            :  * @table: Pointer to battery resistance temperature table
     727                 :            :  * @table_len: The table length
     728                 :            :  * @ocv: Current temperature
     729                 :            :  *
     730                 :            :  * This helper function is used to look up battery internal resistance percent
     731                 :            :  * according to current temperature value from the resistance temperature table,
     732                 :            :  * and the table must be ordered descending. Then the actual battery internal
     733                 :            :  * resistance = the ideal battery internal resistance * percent / 100.
     734                 :            :  *
     735                 :            :  * Return: the battery internal resistance percent
     736                 :            :  */
     737                 :          0 : int power_supply_temp2resist_simple(struct power_supply_resistance_temp_table *table,
     738                 :            :                                     int table_len, int temp)
     739                 :            : {
     740                 :          0 :         int i, resist;
     741                 :            : 
     742         [ #  # ]:          0 :         for (i = 0; i < table_len; i++)
     743         [ #  # ]:          0 :                 if (temp > table[i].temp)
     744                 :            :                         break;
     745                 :            : 
     746         [ #  # ]:          0 :         if (i > 0 && i < table_len) {
     747                 :          0 :                 int tmp;
     748                 :            : 
     749                 :          0 :                 tmp = (table[i - 1].resistance - table[i].resistance) *
     750                 :          0 :                         (temp - table[i].temp);
     751                 :          0 :                 tmp /= table[i - 1].temp - table[i].temp;
     752                 :          0 :                 resist = tmp + table[i].resistance;
     753         [ #  # ]:          0 :         } else if (i == 0) {
     754                 :          0 :                 resist = table[0].resistance;
     755                 :            :         } else {
     756                 :          0 :                 resist = table[table_len - 1].resistance;
     757                 :            :         }
     758                 :            : 
     759                 :          0 :         return resist;
     760                 :            : }
     761                 :            : EXPORT_SYMBOL_GPL(power_supply_temp2resist_simple);
     762                 :            : 
     763                 :            : /**
     764                 :            :  * power_supply_ocv2cap_simple() - find the battery capacity
     765                 :            :  * @table: Pointer to battery OCV lookup table
     766                 :            :  * @table_len: OCV table length
     767                 :            :  * @ocv: Current OCV value
     768                 :            :  *
     769                 :            :  * This helper function is used to look up battery capacity according to
     770                 :            :  * current OCV value from one OCV table, and the OCV table must be ordered
     771                 :            :  * descending.
     772                 :            :  *
     773                 :            :  * Return: the battery capacity.
     774                 :            :  */
     775                 :          0 : int power_supply_ocv2cap_simple(struct power_supply_battery_ocv_table *table,
     776                 :            :                                 int table_len, int ocv)
     777                 :            : {
     778                 :          0 :         int i, cap, tmp;
     779                 :            : 
     780         [ #  # ]:          0 :         for (i = 0; i < table_len; i++)
     781         [ #  # ]:          0 :                 if (ocv > table[i].ocv)
     782                 :            :                         break;
     783                 :            : 
     784         [ #  # ]:          0 :         if (i > 0 && i < table_len) {
     785                 :          0 :                 tmp = (table[i - 1].capacity - table[i].capacity) *
     786                 :          0 :                         (ocv - table[i].ocv);
     787                 :          0 :                 tmp /= table[i - 1].ocv - table[i].ocv;
     788                 :          0 :                 cap = tmp + table[i].capacity;
     789         [ #  # ]:          0 :         } else if (i == 0) {
     790                 :          0 :                 cap = table[0].capacity;
     791                 :            :         } else {
     792                 :          0 :                 cap = table[table_len - 1].capacity;
     793                 :            :         }
     794                 :            : 
     795                 :          0 :         return cap;
     796                 :            : }
     797                 :            : EXPORT_SYMBOL_GPL(power_supply_ocv2cap_simple);
     798                 :            : 
     799                 :            : struct power_supply_battery_ocv_table *
     800                 :          0 : power_supply_find_ocv2cap_table(struct power_supply_battery_info *info,
     801                 :            :                                 int temp, int *table_len)
     802                 :            : {
     803                 :          0 :         int best_temp_diff = INT_MAX, temp_diff;
     804                 :          0 :         u8 i, best_index = 0;
     805                 :            : 
     806         [ #  # ]:          0 :         if (!info->ocv_table[0])
     807                 :            :                 return NULL;
     808                 :            : 
     809   [ #  #  #  # ]:          0 :         for (i = 0; i < POWER_SUPPLY_OCV_TEMP_MAX; i++) {
     810                 :          0 :                 temp_diff = abs(info->ocv_temp[i] - temp);
     811                 :            : 
     812   [ #  #  #  # ]:          0 :                 if (temp_diff < best_temp_diff) {
     813                 :          0 :                         best_temp_diff = temp_diff;
     814                 :          0 :                         best_index = i;
     815                 :            :                 }
     816                 :            :         }
     817                 :            : 
     818                 :          0 :         *table_len = info->ocv_table_size[best_index];
     819                 :          0 :         return info->ocv_table[best_index];
     820                 :            : }
     821                 :            : EXPORT_SYMBOL_GPL(power_supply_find_ocv2cap_table);
     822                 :            : 
     823                 :          0 : int power_supply_batinfo_ocv2cap(struct power_supply_battery_info *info,
     824                 :            :                                  int ocv, int temp)
     825                 :            : {
     826                 :          0 :         struct power_supply_battery_ocv_table *table;
     827                 :          0 :         int table_len;
     828                 :            : 
     829         [ #  # ]:          0 :         table = power_supply_find_ocv2cap_table(info, temp, &table_len);
     830         [ #  # ]:          0 :         if (!table)
     831                 :            :                 return -EINVAL;
     832                 :            : 
     833                 :          0 :         return power_supply_ocv2cap_simple(table, table_len, ocv);
     834                 :            : }
     835                 :            : EXPORT_SYMBOL_GPL(power_supply_batinfo_ocv2cap);
     836                 :            : 
     837                 :          0 : int power_supply_get_property(struct power_supply *psy,
     838                 :            :                             enum power_supply_property psp,
     839                 :            :                             union power_supply_propval *val)
     840                 :            : {
     841         [ #  # ]:          0 :         if (atomic_read(&psy->use_cnt) <= 0) {
     842         [ #  # ]:          0 :                 if (!psy->initialized)
     843                 :            :                         return -EAGAIN;
     844                 :          0 :                 return -ENODEV;
     845                 :            :         }
     846                 :            : 
     847                 :          0 :         return psy->desc->get_property(psy, psp, val);
     848                 :            : }
     849                 :            : EXPORT_SYMBOL_GPL(power_supply_get_property);
     850                 :            : 
     851                 :          0 : int power_supply_set_property(struct power_supply *psy,
     852                 :            :                             enum power_supply_property psp,
     853                 :            :                             const union power_supply_propval *val)
     854                 :            : {
     855   [ #  #  #  # ]:          0 :         if (atomic_read(&psy->use_cnt) <= 0 || !psy->desc->set_property)
     856                 :            :                 return -ENODEV;
     857                 :            : 
     858                 :          0 :         return psy->desc->set_property(psy, psp, val);
     859                 :            : }
     860                 :            : EXPORT_SYMBOL_GPL(power_supply_set_property);
     861                 :            : 
     862                 :          0 : int power_supply_property_is_writeable(struct power_supply *psy,
     863                 :            :                                         enum power_supply_property psp)
     864                 :            : {
     865         [ #  # ]:          0 :         if (atomic_read(&psy->use_cnt) <= 0 ||
     866         [ #  # ]:          0 :                         !psy->desc->property_is_writeable)
     867                 :            :                 return -ENODEV;
     868                 :            : 
     869                 :          0 :         return psy->desc->property_is_writeable(psy, psp);
     870                 :            : }
     871                 :            : EXPORT_SYMBOL_GPL(power_supply_property_is_writeable);
     872                 :            : 
     873                 :          0 : void power_supply_external_power_changed(struct power_supply *psy)
     874                 :            : {
     875         [ #  # ]:          0 :         if (atomic_read(&psy->use_cnt) <= 0 ||
     876         [ #  # ]:          0 :                         !psy->desc->external_power_changed)
     877                 :            :                 return;
     878                 :            : 
     879                 :          0 :         psy->desc->external_power_changed(psy);
     880                 :            : }
     881                 :            : EXPORT_SYMBOL_GPL(power_supply_external_power_changed);
     882                 :            : 
     883                 :          0 : int power_supply_powers(struct power_supply *psy, struct device *dev)
     884                 :            : {
     885                 :          0 :         return sysfs_create_link(&psy->dev.kobj, &dev->kobj, "powers");
     886                 :            : }
     887                 :            : EXPORT_SYMBOL_GPL(power_supply_powers);
     888                 :            : 
     889                 :          0 : static void power_supply_dev_release(struct device *dev)
     890                 :            : {
     891                 :          0 :         struct power_supply *psy = to_power_supply(dev);
     892                 :          0 :         dev_dbg(dev, "%s\n", __func__);
     893                 :          0 :         kfree(psy);
     894                 :          0 : }
     895                 :            : 
     896                 :          0 : int power_supply_reg_notifier(struct notifier_block *nb)
     897                 :            : {
     898                 :          0 :         return atomic_notifier_chain_register(&power_supply_notifier, nb);
     899                 :            : }
     900                 :            : EXPORT_SYMBOL_GPL(power_supply_reg_notifier);
     901                 :            : 
     902                 :          0 : void power_supply_unreg_notifier(struct notifier_block *nb)
     903                 :            : {
     904                 :          0 :         atomic_notifier_chain_unregister(&power_supply_notifier, nb);
     905                 :          0 : }
     906                 :            : EXPORT_SYMBOL_GPL(power_supply_unreg_notifier);
     907                 :            : 
     908                 :            : #ifdef CONFIG_THERMAL
     909                 :          0 : static int power_supply_read_temp(struct thermal_zone_device *tzd,
     910                 :            :                 int *temp)
     911                 :            : {
     912                 :          0 :         struct power_supply *psy;
     913                 :          0 :         union power_supply_propval val;
     914                 :          0 :         int ret;
     915                 :            : 
     916         [ #  # ]:          0 :         WARN_ON(tzd == NULL);
     917                 :          0 :         psy = tzd->devdata;
     918                 :          0 :         ret = power_supply_get_property(psy, POWER_SUPPLY_PROP_TEMP, &val);
     919         [ #  # ]:          0 :         if (ret)
     920                 :            :                 return ret;
     921                 :            : 
     922                 :            :         /* Convert tenths of degree Celsius to milli degree Celsius. */
     923                 :          0 :         *temp = val.intval * 100;
     924                 :            : 
     925                 :          0 :         return ret;
     926                 :            : }
     927                 :            : 
     928                 :            : static struct thermal_zone_device_ops psy_tzd_ops = {
     929                 :            :         .get_temp = power_supply_read_temp,
     930                 :            : };
     931                 :            : 
     932                 :          0 : static int psy_register_thermal(struct power_supply *psy)
     933                 :            : {
     934                 :          0 :         int i;
     935                 :            : 
     936         [ #  # ]:          0 :         if (psy->desc->no_thermal)
     937                 :            :                 return 0;
     938                 :            : 
     939                 :            :         /* Register battery zone device psy reports temperature */
     940         [ #  # ]:          0 :         for (i = 0; i < psy->desc->num_properties; i++) {
     941         [ #  # ]:          0 :                 if (psy->desc->properties[i] == POWER_SUPPLY_PROP_TEMP) {
     942                 :          0 :                         psy->tzd = thermal_zone_device_register(psy->desc->name,
     943                 :            :                                         0, 0, psy, &psy_tzd_ops, NULL, 0, 0);
     944         [ #  # ]:          0 :                         return PTR_ERR_OR_ZERO(psy->tzd);
     945                 :            :                 }
     946                 :            :         }
     947                 :            :         return 0;
     948                 :            : }
     949                 :            : 
     950                 :          0 : static void psy_unregister_thermal(struct power_supply *psy)
     951                 :            : {
     952   [ #  #  #  # ]:          0 :         if (IS_ERR_OR_NULL(psy->tzd))
     953                 :            :                 return;
     954                 :          0 :         thermal_zone_device_unregister(psy->tzd);
     955                 :            : }
     956                 :            : 
     957                 :            : /* thermal cooling device callbacks */
     958                 :          0 : static int ps_get_max_charge_cntl_limit(struct thermal_cooling_device *tcd,
     959                 :            :                                         unsigned long *state)
     960                 :            : {
     961                 :          0 :         struct power_supply *psy;
     962                 :          0 :         union power_supply_propval val;
     963                 :          0 :         int ret;
     964                 :            : 
     965                 :          0 :         psy = tcd->devdata;
     966                 :          0 :         ret = power_supply_get_property(psy,
     967                 :            :                         POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT_MAX, &val);
     968         [ #  # ]:          0 :         if (ret)
     969                 :            :                 return ret;
     970                 :            : 
     971                 :          0 :         *state = val.intval;
     972                 :            : 
     973                 :          0 :         return ret;
     974                 :            : }
     975                 :            : 
     976                 :          0 : static int ps_get_cur_charge_cntl_limit(struct thermal_cooling_device *tcd,
     977                 :            :                                         unsigned long *state)
     978                 :            : {
     979                 :          0 :         struct power_supply *psy;
     980                 :          0 :         union power_supply_propval val;
     981                 :          0 :         int ret;
     982                 :            : 
     983                 :          0 :         psy = tcd->devdata;
     984                 :          0 :         ret = power_supply_get_property(psy,
     985                 :            :                         POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT, &val);
     986         [ #  # ]:          0 :         if (ret)
     987                 :            :                 return ret;
     988                 :            : 
     989                 :          0 :         *state = val.intval;
     990                 :            : 
     991                 :          0 :         return ret;
     992                 :            : }
     993                 :            : 
     994                 :          0 : static int ps_set_cur_charge_cntl_limit(struct thermal_cooling_device *tcd,
     995                 :            :                                         unsigned long state)
     996                 :            : {
     997                 :          0 :         struct power_supply *psy;
     998                 :          0 :         union power_supply_propval val;
     999                 :          0 :         int ret;
    1000                 :            : 
    1001                 :          0 :         psy = tcd->devdata;
    1002                 :          0 :         val.intval = state;
    1003                 :          0 :         ret = psy->desc->set_property(psy,
    1004                 :            :                 POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT, &val);
    1005                 :            : 
    1006                 :          0 :         return ret;
    1007                 :            : }
    1008                 :            : 
    1009                 :            : static const struct thermal_cooling_device_ops psy_tcd_ops = {
    1010                 :            :         .get_max_state = ps_get_max_charge_cntl_limit,
    1011                 :            :         .get_cur_state = ps_get_cur_charge_cntl_limit,
    1012                 :            :         .set_cur_state = ps_set_cur_charge_cntl_limit,
    1013                 :            : };
    1014                 :            : 
    1015                 :          0 : static int psy_register_cooler(struct power_supply *psy)
    1016                 :            : {
    1017                 :          0 :         int i;
    1018                 :            : 
    1019                 :            :         /* Register for cooling device if psy can control charging */
    1020         [ #  # ]:          0 :         for (i = 0; i < psy->desc->num_properties; i++) {
    1021         [ #  # ]:          0 :                 if (psy->desc->properties[i] ==
    1022                 :            :                                 POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT) {
    1023                 :          0 :                         psy->tcd = thermal_cooling_device_register(
    1024                 :          0 :                                                         (char *)psy->desc->name,
    1025                 :            :                                                         psy, &psy_tcd_ops);
    1026         [ #  # ]:          0 :                         return PTR_ERR_OR_ZERO(psy->tcd);
    1027                 :            :                 }
    1028                 :            :         }
    1029                 :            :         return 0;
    1030                 :            : }
    1031                 :            : 
    1032                 :          0 : static void psy_unregister_cooler(struct power_supply *psy)
    1033                 :            : {
    1034   [ #  #  #  # ]:          0 :         if (IS_ERR_OR_NULL(psy->tcd))
    1035                 :            :                 return;
    1036                 :          0 :         thermal_cooling_device_unregister(psy->tcd);
    1037                 :            : }
    1038                 :            : #else
    1039                 :            : static int psy_register_thermal(struct power_supply *psy)
    1040                 :            : {
    1041                 :            :         return 0;
    1042                 :            : }
    1043                 :            : 
    1044                 :            : static void psy_unregister_thermal(struct power_supply *psy)
    1045                 :            : {
    1046                 :            : }
    1047                 :            : 
    1048                 :            : static int psy_register_cooler(struct power_supply *psy)
    1049                 :            : {
    1050                 :            :         return 0;
    1051                 :            : }
    1052                 :            : 
    1053                 :            : static void psy_unregister_cooler(struct power_supply *psy)
    1054                 :            : {
    1055                 :            : }
    1056                 :            : #endif
    1057                 :            : 
    1058                 :            : static struct power_supply *__must_check
    1059                 :          0 : __power_supply_register(struct device *parent,
    1060                 :            :                                    const struct power_supply_desc *desc,
    1061                 :            :                                    const struct power_supply_config *cfg,
    1062                 :            :                                    bool ws)
    1063                 :            : {
    1064                 :          0 :         struct device *dev;
    1065                 :          0 :         struct power_supply *psy;
    1066                 :          0 :         int i, rc;
    1067                 :            : 
    1068         [ #  # ]:          0 :         if (!parent)
    1069                 :          0 :                 pr_warn("%s: Expected proper parent device for '%s'\n",
    1070                 :            :                         __func__, desc->name);
    1071                 :            : 
    1072   [ #  #  #  #  :          0 :         if (!desc || !desc->name || !desc->properties || !desc->num_properties)
             #  #  #  # ]
    1073                 :            :                 return ERR_PTR(-EINVAL);
    1074                 :            : 
    1075         [ #  # ]:          0 :         for (i = 0; i < desc->num_properties; ++i) {
    1076         [ #  # ]:          0 :                 if ((desc->properties[i] == POWER_SUPPLY_PROP_USB_TYPE) &&
    1077   [ #  #  #  # ]:          0 :                     (!desc->usb_types || !desc->num_usb_types))
    1078                 :            :                         return ERR_PTR(-EINVAL);
    1079                 :            :         }
    1080                 :            : 
    1081                 :          0 :         psy = kzalloc(sizeof(*psy), GFP_KERNEL);
    1082         [ #  # ]:          0 :         if (!psy)
    1083                 :            :                 return ERR_PTR(-ENOMEM);
    1084                 :            : 
    1085                 :          0 :         dev = &psy->dev;
    1086                 :            : 
    1087                 :          0 :         device_initialize(dev);
    1088                 :            : 
    1089                 :          0 :         dev->class = power_supply_class;
    1090                 :          0 :         dev->type = &power_supply_dev_type;
    1091                 :          0 :         dev->parent = parent;
    1092                 :          0 :         dev->release = power_supply_dev_release;
    1093         [ #  # ]:          0 :         dev_set_drvdata(dev, psy);
    1094                 :          0 :         psy->desc = desc;
    1095         [ #  # ]:          0 :         if (cfg) {
    1096                 :          0 :                 dev->groups = cfg->attr_grp;
    1097                 :          0 :                 psy->drv_data = cfg->drv_data;
    1098                 :          0 :                 psy->of_node =
    1099         [ #  # ]:          0 :                         cfg->fwnode ? to_of_node(cfg->fwnode) : cfg->of_node;
    1100                 :          0 :                 psy->supplied_to = cfg->supplied_to;
    1101                 :          0 :                 psy->num_supplicants = cfg->num_supplicants;
    1102                 :            :         }
    1103                 :            : 
    1104                 :          0 :         rc = dev_set_name(dev, "%s", desc->name);
    1105         [ #  # ]:          0 :         if (rc)
    1106                 :          0 :                 goto dev_set_name_failed;
    1107                 :            : 
    1108                 :          0 :         INIT_WORK(&psy->changed_work, power_supply_changed_work);
    1109                 :          0 :         INIT_DELAYED_WORK(&psy->deferred_register_work,
    1110                 :            :                           power_supply_deferred_register_work);
    1111                 :            : 
    1112                 :          0 :         rc = power_supply_check_supplies(psy);
    1113         [ #  # ]:          0 :         if (rc) {
    1114                 :          0 :                 dev_info(dev, "Not all required supplies found, defer probe\n");
    1115                 :          0 :                 goto check_supplies_failed;
    1116                 :            :         }
    1117                 :            : 
    1118                 :          0 :         spin_lock_init(&psy->changed_lock);
    1119                 :          0 :         rc = device_add(dev);
    1120         [ #  # ]:          0 :         if (rc)
    1121                 :          0 :                 goto device_add_failed;
    1122                 :            : 
    1123                 :          0 :         rc = device_init_wakeup(dev, ws);
    1124         [ #  # ]:          0 :         if (rc)
    1125                 :          0 :                 goto wakeup_init_failed;
    1126                 :            : 
    1127                 :          0 :         rc = psy_register_thermal(psy);
    1128         [ #  # ]:          0 :         if (rc)
    1129                 :          0 :                 goto register_thermal_failed;
    1130                 :            : 
    1131                 :          0 :         rc = psy_register_cooler(psy);
    1132         [ #  # ]:          0 :         if (rc)
    1133                 :          0 :                 goto register_cooler_failed;
    1134                 :            : 
    1135                 :          0 :         rc = power_supply_create_triggers(psy);
    1136         [ #  # ]:          0 :         if (rc)
    1137                 :          0 :                 goto create_triggers_failed;
    1138                 :            : 
    1139                 :          0 :         rc = power_supply_add_hwmon_sysfs(psy);
    1140         [ #  # ]:          0 :         if (rc)
    1141                 :          0 :                 goto add_hwmon_sysfs_failed;
    1142                 :            : 
    1143                 :            :         /*
    1144                 :            :          * Update use_cnt after any uevents (most notably from device_add()).
    1145                 :            :          * We are here still during driver's probe but
    1146                 :            :          * the power_supply_uevent() calls back driver's get_property
    1147                 :            :          * method so:
    1148                 :            :          * 1. Driver did not assigned the returned struct power_supply,
    1149                 :            :          * 2. Driver could not finish initialization (anything in its probe
    1150                 :            :          *    after calling power_supply_register()).
    1151                 :            :          */
    1152                 :          0 :         atomic_inc(&psy->use_cnt);
    1153                 :          0 :         psy->initialized = true;
    1154                 :            : 
    1155                 :          0 :         queue_delayed_work(system_power_efficient_wq,
    1156                 :            :                            &psy->deferred_register_work,
    1157                 :            :                            POWER_SUPPLY_DEFERRED_REGISTER_TIME);
    1158                 :            : 
    1159                 :          0 :         return psy;
    1160                 :            : 
    1161                 :            : add_hwmon_sysfs_failed:
    1162                 :          0 :         power_supply_remove_triggers(psy);
    1163                 :          0 : create_triggers_failed:
    1164         [ #  # ]:          0 :         psy_unregister_cooler(psy);
    1165                 :          0 : register_cooler_failed:
    1166         [ #  # ]:          0 :         psy_unregister_thermal(psy);
    1167                 :          0 : register_thermal_failed:
    1168                 :          0 :         device_del(dev);
    1169                 :          0 : wakeup_init_failed:
    1170                 :          0 : device_add_failed:
    1171                 :          0 : check_supplies_failed:
    1172                 :          0 : dev_set_name_failed:
    1173                 :          0 :         put_device(dev);
    1174                 :          0 :         return ERR_PTR(rc);
    1175                 :            : }
    1176                 :            : 
    1177                 :            : /**
    1178                 :            :  * power_supply_register() - Register new power supply
    1179                 :            :  * @parent:     Device to be a parent of power supply's device, usually
    1180                 :            :  *              the device which probe function calls this
    1181                 :            :  * @desc:       Description of power supply, must be valid through whole
    1182                 :            :  *              lifetime of this power supply
    1183                 :            :  * @cfg:        Run-time specific configuration accessed during registering,
    1184                 :            :  *              may be NULL
    1185                 :            :  *
    1186                 :            :  * Return: A pointer to newly allocated power_supply on success
    1187                 :            :  * or ERR_PTR otherwise.
    1188                 :            :  * Use power_supply_unregister() on returned power_supply pointer to release
    1189                 :            :  * resources.
    1190                 :            :  */
    1191                 :          0 : struct power_supply *__must_check power_supply_register(struct device *parent,
    1192                 :            :                 const struct power_supply_desc *desc,
    1193                 :            :                 const struct power_supply_config *cfg)
    1194                 :            : {
    1195                 :          0 :         return __power_supply_register(parent, desc, cfg, true);
    1196                 :            : }
    1197                 :            : EXPORT_SYMBOL_GPL(power_supply_register);
    1198                 :            : 
    1199                 :            : /**
    1200                 :            :  * power_supply_register_no_ws() - Register new non-waking-source power supply
    1201                 :            :  * @parent:     Device to be a parent of power supply's device, usually
    1202                 :            :  *              the device which probe function calls this
    1203                 :            :  * @desc:       Description of power supply, must be valid through whole
    1204                 :            :  *              lifetime of this power supply
    1205                 :            :  * @cfg:        Run-time specific configuration accessed during registering,
    1206                 :            :  *              may be NULL
    1207                 :            :  *
    1208                 :            :  * Return: A pointer to newly allocated power_supply on success
    1209                 :            :  * or ERR_PTR otherwise.
    1210                 :            :  * Use power_supply_unregister() on returned power_supply pointer to release
    1211                 :            :  * resources.
    1212                 :            :  */
    1213                 :            : struct power_supply *__must_check
    1214                 :          0 : power_supply_register_no_ws(struct device *parent,
    1215                 :            :                 const struct power_supply_desc *desc,
    1216                 :            :                 const struct power_supply_config *cfg)
    1217                 :            : {
    1218                 :          0 :         return __power_supply_register(parent, desc, cfg, false);
    1219                 :            : }
    1220                 :            : EXPORT_SYMBOL_GPL(power_supply_register_no_ws);
    1221                 :            : 
    1222                 :          0 : static void devm_power_supply_release(struct device *dev, void *res)
    1223                 :            : {
    1224                 :          0 :         struct power_supply **psy = res;
    1225                 :            : 
    1226                 :          0 :         power_supply_unregister(*psy);
    1227                 :          0 : }
    1228                 :            : 
    1229                 :            : /**
    1230                 :            :  * devm_power_supply_register() - Register managed power supply
    1231                 :            :  * @parent:     Device to be a parent of power supply's device, usually
    1232                 :            :  *              the device which probe function calls this
    1233                 :            :  * @desc:       Description of power supply, must be valid through whole
    1234                 :            :  *              lifetime of this power supply
    1235                 :            :  * @cfg:        Run-time specific configuration accessed during registering,
    1236                 :            :  *              may be NULL
    1237                 :            :  *
    1238                 :            :  * Return: A pointer to newly allocated power_supply on success
    1239                 :            :  * or ERR_PTR otherwise.
    1240                 :            :  * The returned power_supply pointer will be automatically unregistered
    1241                 :            :  * on driver detach.
    1242                 :            :  */
    1243                 :            : struct power_supply *__must_check
    1244                 :          0 : devm_power_supply_register(struct device *parent,
    1245                 :            :                 const struct power_supply_desc *desc,
    1246                 :            :                 const struct power_supply_config *cfg)
    1247                 :            : {
    1248                 :          0 :         struct power_supply **ptr, *psy;
    1249                 :            : 
    1250                 :          0 :         ptr = devres_alloc(devm_power_supply_release, sizeof(*ptr), GFP_KERNEL);
    1251                 :            : 
    1252         [ #  # ]:          0 :         if (!ptr)
    1253                 :            :                 return ERR_PTR(-ENOMEM);
    1254                 :          0 :         psy = __power_supply_register(parent, desc, cfg, true);
    1255         [ #  # ]:          0 :         if (IS_ERR(psy)) {
    1256                 :          0 :                 devres_free(ptr);
    1257                 :            :         } else {
    1258                 :          0 :                 *ptr = psy;
    1259                 :          0 :                 devres_add(parent, ptr);
    1260                 :            :         }
    1261                 :            :         return psy;
    1262                 :            : }
    1263                 :            : EXPORT_SYMBOL_GPL(devm_power_supply_register);
    1264                 :            : 
    1265                 :            : /**
    1266                 :            :  * devm_power_supply_register_no_ws() - Register managed non-waking-source power supply
    1267                 :            :  * @parent:     Device to be a parent of power supply's device, usually
    1268                 :            :  *              the device which probe function calls this
    1269                 :            :  * @desc:       Description of power supply, must be valid through whole
    1270                 :            :  *              lifetime of this power supply
    1271                 :            :  * @cfg:        Run-time specific configuration accessed during registering,
    1272                 :            :  *              may be NULL
    1273                 :            :  *
    1274                 :            :  * Return: A pointer to newly allocated power_supply on success
    1275                 :            :  * or ERR_PTR otherwise.
    1276                 :            :  * The returned power_supply pointer will be automatically unregistered
    1277                 :            :  * on driver detach.
    1278                 :            :  */
    1279                 :            : struct power_supply *__must_check
    1280                 :          0 : devm_power_supply_register_no_ws(struct device *parent,
    1281                 :            :                 const struct power_supply_desc *desc,
    1282                 :            :                 const struct power_supply_config *cfg)
    1283                 :            : {
    1284                 :          0 :         struct power_supply **ptr, *psy;
    1285                 :            : 
    1286                 :          0 :         ptr = devres_alloc(devm_power_supply_release, sizeof(*ptr), GFP_KERNEL);
    1287                 :            : 
    1288         [ #  # ]:          0 :         if (!ptr)
    1289                 :            :                 return ERR_PTR(-ENOMEM);
    1290                 :          0 :         psy = __power_supply_register(parent, desc, cfg, false);
    1291         [ #  # ]:          0 :         if (IS_ERR(psy)) {
    1292                 :          0 :                 devres_free(ptr);
    1293                 :            :         } else {
    1294                 :          0 :                 *ptr = psy;
    1295                 :          0 :                 devres_add(parent, ptr);
    1296                 :            :         }
    1297                 :            :         return psy;
    1298                 :            : }
    1299                 :            : EXPORT_SYMBOL_GPL(devm_power_supply_register_no_ws);
    1300                 :            : 
    1301                 :            : /**
    1302                 :            :  * power_supply_unregister() - Remove this power supply from system
    1303                 :            :  * @psy:        Pointer to power supply to unregister
    1304                 :            :  *
    1305                 :            :  * Remove this power supply from the system. The resources of power supply
    1306                 :            :  * will be freed here or on last power_supply_put() call.
    1307                 :            :  */
    1308                 :          0 : void power_supply_unregister(struct power_supply *psy)
    1309                 :            : {
    1310         [ #  # ]:          0 :         WARN_ON(atomic_dec_return(&psy->use_cnt));
    1311                 :          0 :         psy->removing = true;
    1312                 :          0 :         cancel_work_sync(&psy->changed_work);
    1313                 :          0 :         cancel_delayed_work_sync(&psy->deferred_register_work);
    1314                 :          0 :         sysfs_remove_link(&psy->dev.kobj, "powers");
    1315                 :          0 :         power_supply_remove_hwmon_sysfs(psy);
    1316                 :          0 :         power_supply_remove_triggers(psy);
    1317         [ #  # ]:          0 :         psy_unregister_cooler(psy);
    1318         [ #  # ]:          0 :         psy_unregister_thermal(psy);
    1319                 :          0 :         device_init_wakeup(&psy->dev, false);
    1320                 :          0 :         device_unregister(&psy->dev);
    1321                 :          0 : }
    1322                 :            : EXPORT_SYMBOL_GPL(power_supply_unregister);
    1323                 :            : 
    1324                 :          0 : void *power_supply_get_drvdata(struct power_supply *psy)
    1325                 :            : {
    1326                 :          0 :         return psy->drv_data;
    1327                 :            : }
    1328                 :            : EXPORT_SYMBOL_GPL(power_supply_get_drvdata);
    1329                 :            : 
    1330                 :         13 : static int __init power_supply_class_init(void)
    1331                 :            : {
    1332                 :         13 :         power_supply_class = class_create(THIS_MODULE, "power_supply");
    1333                 :            : 
    1334         [ -  + ]:         13 :         if (IS_ERR(power_supply_class))
    1335                 :          0 :                 return PTR_ERR(power_supply_class);
    1336                 :            : 
    1337                 :         13 :         power_supply_class->dev_uevent = power_supply_uevent;
    1338                 :         13 :         power_supply_init_attrs(&power_supply_dev_type);
    1339                 :            : 
    1340                 :         13 :         return 0;
    1341                 :            : }
    1342                 :            : 
    1343                 :          0 : static void __exit power_supply_class_exit(void)
    1344                 :            : {
    1345                 :          0 :         class_destroy(power_supply_class);
    1346                 :          0 : }
    1347                 :            : 
    1348                 :            : subsys_initcall(power_supply_class_init);
    1349                 :            : module_exit(power_supply_class_exit);
    1350                 :            : 
    1351                 :            : MODULE_DESCRIPTION("Universal power supply monitor class");
    1352                 :            : MODULE_AUTHOR("Ian Molton <spyro@f2s.com>, "
    1353                 :            :               "Szabolcs Gyurko, "
    1354                 :            :               "Anton Vorontsov <cbou@mail.ru>");
    1355                 :            : MODULE_LICENSE("GPL");

Generated by: LCOV version 1.14