1.概述

对于便携式设备，如手机或者pad来说，battery都是必不可少的一个组成部分。kernel中为了方便对battery的管理，专门提供了power supply framework。

battery管理我觉得可以分开为两个部分，一个是电池监控（fuelgauge），另一个是充放电管理（charger），所以我们在内核中也是把它分成了两个驱动来管理。

电池监控（fuelgauge）驱动主要是负责向上层android系统提供当前电池的电量以及健康状态信息等等，另外除了这个以外，它也向charger驱动提供电池的相关信息；

充放电管理（charger）驱动主要负责电源线的插拔检测，以及充放电的过程管理。对于battery管理，硬件上有电量计IC和充放电IC。

2.Power Supply设计思路

先来回答一个问题：kernel中设备驱动的目的，是管理设备，并提供给用户空间程序使用，那么对PSY设备而言，kernel要管理什么？用户空间程序要使用什么？

其实PSY设备是一个特例，它的目的很单纯，就为系统供电。如果只考虑这个目的，就不需要任何驱动了，但情况会稍微复杂，因为：

1.PSY设备可能是电池，这引申出来电量检测， 充电管理等多个议题。此时，PSY driver需要管理的事情包括：检测电池类型，检测电池电量；检测充电状态等等。而用户空间则需要将检测到的结果显示给用户。

2.系统中可能有多个PSY设备，这些设备可能还有级联关系，如有些平板电脑中，可能同时存在DC-charger、USB-charger和battery供电。此时，PSY driver需要管理的事情包括，获取外部供电设备的连接状态，充电状态等等，用户空间需要将这些信息显示给用户。

那么，共性已经总结出来了，PSY driver的主要功能，就是向用户空间汇报各类状态信息，因此power supply class的核心思路就是：将这些状态信息，抽象为属性“properties”。由于状态信息是类型是有限的，properties的个数也是有限的。

PSY driver只需要负责：该PSY设备具备有哪些“属性”，这些“属性”的值（value）是什么；当属性值发生改变时，通知power supply class。

power supply class负责：将某个PSY 设备支持的属性及value，以sysfs的形式，提供给用户空间，当属性值改变时，以uevent的形式，广播给用户空间程序。

另外，power supply class也会协助处理PSY级联的情况。

3.Power Supply软件架构

power supply framework在kernel/drivers/power/下。内核抽象出来power supply子系统为驱动提供了统一的框架。功能包括：

1.抽象PSY设备的共性，向用户空间提供统一的API

   2.为底层PSY驱动的编写，提供简单、统一的方式。同事封装并实现公共逻辑。

power supply class位于drivers/power/目录中，主要由3部分组成（可参考下图的软件架构）：

1）power supply core，用于抽象核心数据结构、实现公共逻辑。位于drivers/power/power_supply_core.c中。

2）power supply sysfs，实现sysfs以及uevent功能。位于drivers/power/power_supply_sysfs.c中。

3）power supply leds，基于linux led class，提供PSY设备状态指示的通用实现。位于drivers/power/power_suppply_leds.c中。

最后，驱动工程师可以基于power supply class，实现具体的PSY drivers，主要处理平台相关、硬件相关的逻辑。这些drivers都位于drivers/power/目录下。

接着来看一下核心数据结构drivers/power/power_supply_core.c中。

1.struct power_supply

struct power_supply为power supply class的核心数据结构，用于抽象PSY设备，定义如下(kernel/msm-4.19/include/linux/power_supply.h)：

1. struct power_supply {
2.        const char *name;   //该PSY的名称
3.        enum power_supply_type type; //该PSY的类型，枚举类型，一般包括:battery、USB-charger、DC-charger。
4.        enum power_supply_property *properties; //该PSY具有的属性列表，枚举型。
5. #ifdef CONFIG_CHARGING_NODEADD

        Int charge_node_add    //需要添加节点的话要在这里添加节点属性

#endif

1.        size_t num_properties;  //属性的个数
3.        char **supplied_to; //一个字符串数组，保存了由该PSY供电的PSY列表，以此可将PAY组成互相级联的PSY链表。这些被供电的PSY，称作supplicant（客户端，乞求者）
4.        size_t num_supplicants;//supplicant的个数。
6.        char **supplied_from; //一个字符串数组，保存了该PSY供电的PSY列表，也称作supply（提供者），从另外一个方向组织PSY之间的级联关系。
7.        size_t num_supplies; //supply的个数
8. #ifdef CONFIG_OF
9.        struct device_node *of_node; //用于保存of_node指针。
10. #endif
12.        int (*get_property)(struct power_supply *psy, //PSY driver需要实现的回调函数，用于获取属性值。
13.                           enum power_supply_property psp,
14.                           union power_supply_propval *val);
15.        int (*set_property)(struct power_supply *psy,  //PSY driver需要实现的回调函数，用于设置属性值。
16.                             enum power_supply_property psp,
17.                           const union power_supply_propval *val);
18.        int (*property_is_writeable)(struct power_supply *psy,  //返回指定的属性值是否可写（用于sysfs）；
19.                                    enum power_supply_property psp);
20.        void (*external_power_changed)(struct power_supply *psy); //当一个PSY设备存在supply PSY，且该supply PSY的属性发生改变（如online offline）时，power supply core会调用该回调函数，通知PSY driver以便让它做出相应处理。
21.        void (*set_charged)(struct power_supply *psy);     //该回调函数的应用场景有点奇怪，外部模块通知PAY driver，该PSY设备的状态改变了，自己改变了自己不知道，要外部通知，希望大家在实际工作中不要遇到，太纠结了。
23.       
24.        int use_for_apm;
26.       
27.        struct device *dev;
28.        struct work_struct changed_work; //用户处理状态改变的work queue，主要思路是当该PSY的状态发生改变，启动一个workqueue，查询并通知所有的supplicants。
29.        spinlock_t changed_lock;
30.        bool changed;
31. #ifdef CONFIG_THERMAL
32.        struct thermal_zone_device *tzd;
33.        struct thermal_cooling_device *tcd;
34. #endif
36. #ifdef CONFIG_LEDS_TRIGGERS
37.        struct led_trigger *charging_full_trig;
38.        char *charging_full_trig_name;
39.        struct led_trigger *charging_trig;
40.        char *charging_trig_name;
41.        struct led_trigger *full_trig;
42.        char *full_trig_name;
43.        struct led_trigger *online_trig; //如果配置了CONFIC_LED_TRIGGERS，则调用的linux led class的接口，注册相应的LED设备，用于PSY状态指示。
44.        char *online_trig_name;
45.        struct led_trigger *charging_blink_full_solid_trig;
46.        char *charging_blink_full_solid_trig_name;
47. #endif
48. };

2.PSY的类型

PSY类型由enum power_supply_type(power_supply.h)定义：

1. enum power_supply_type {
2.        POWER_SUPPLY_TYPE_UNKNOWN = 0, //未知
3.        POWER_SUPPLY_TYPE_BATTERY,     //电池，手机平板上面最常用的
4.        POWER_SUPPLY_TYPE_UPS,         //不间断供电的，一般用户服务器   
5.        POWER_SUPPLY_TYPE_MAINS,        //主供电设备，如笔记本电脑适配器，特点是可以单独供电，当其断开时，再由辅助设备供电。
6.        POWER_SUPPLY_TYPE_USB,        
7.        POWER_SUPPLY_TYPE_USB_DCP,    
8.        POWER_SUPPLY_TYPE_USB_CDP,    
9.        POWER_SUPPLY_TYPE_USB_ACA,    
10. };

3.PSY属性

power supply class将所有可能PSY属性(power_supply.h)，以枚举型变量形式抽象出来，PSY driver可以根据设备的实际情况，从中选取一些。

1. enum power_supply_property {
2.       
3.        POWER_SUPPLY_PROP_STATUS = 0, //该PSY的status，主要是充电状态，包括：unknown,charging,discharging,not charging full,
4.        POWER_SUPPLY_PROP_CHARGE_TYPE,//充电类型
5.        POWER_SUPPLY_PROP_HEALTH, //健康状况，包括：good dead  over voltage等
6.        POWER_SUPPLY_PROP_PRESENT, //电量百分比
7.        POWER_SUPPLY_PROP_ONLINE,  //是否在线
8.        POWER_SUPPLY_PROP_AUTHENTIC,
9.        POWER_SUPPLY_PROP_TECHNOLOGY, //采用的技术
10.        POWER_SUPPLY_PROP_CYCLE_COUNT,
11.        POWER_SUPPLY_PROP_VOLTAGE_MAX,
12.        POWER_SUPPLY_PROP_VOLTAGE_MIN,
13.        POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN,
14.        POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
15.        POWER_SUPPLY_PROP_VOLTAGE_NOW,
16.        POWER_SUPPLY_PROP_VOLTAGE_AVG,
17.        POWER_SUPPLY_PROP_VOLTAGE_OCV,
18.        POWER_SUPPLY_PROP_CURRENT_MAX,
19.        POWER_SUPPLY_PROP_CURRENT_NOW,
20.        POWER_SUPPLY_PROP_CURRENT_AVG,
21.        POWER_SUPPLY_PROP_POWER_NOW,
22.        POWER_SUPPLY_PROP_POWER_AVG,
23.        POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
24.        POWER_SUPPLY_PROP_CHARGE_EMPTY_DESIGN,
25.        POWER_SUPPLY_PROP_CHARGE_FULL,
26.        POWER_SUPPLY_PROP_CHARGE_EMPTY,
27.        POWER_SUPPLY_PROP_CHARGE_NOW,
28.        POWER_SUPPLY_PROP_CHARGE_AVG,
29.        POWER_SUPPLY_PROP_CHARGE_COUNTER,
30.        POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT,
31.        POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX,
32.        POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE,
33.        POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX,
34.        POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT,
35.        POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT_MAX,
36.        POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN,
37.        POWER_SUPPLY_PROP_ENERGY_EMPTY_DESIGN,
38.        POWER_SUPPLY_PROP_ENERGY_FULL,
39.        POWER_SUPPLY_PROP_ENERGY_EMPTY,
40.        POWER_SUPPLY_PROP_ENERGY_NOW,
41.        POWER_SUPPLY_PROP_ENERGY_AVG,
42.        POWER_SUPPLY_PROP_CAPACITY,
43.        POWER_SUPPLY_PROP_CAPACITY_ALERT_MIN,
44.        POWER_SUPPLY_PROP_CAPACITY_ALERT_MAX,
45.        POWER_SUPPLY_PROP_CAPACITY_LEVEL, //容量
46.        POWER_SUPPLY_PROP_TEMP,
47.        POWER_SUPPLY_PROP_TEMP_ALERT_MIN,
48.        POWER_SUPPLY_PROP_TEMP_ALERT_MAX,
49.        POWER_SUPPLY_PROP_TEMP_AMBIENT,
50.        POWER_SUPPLY_PROP_TEMP_AMBIENT_ALERT_MIN,
51.        POWER_SUPPLY_PROP_TEMP_AMBIENT_ALERT_MAX,
52.        POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW,
53.        POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG,
54.        POWER_SUPPLY_PROP_TIME_TO_FULL_NOW,
55.        POWER_SUPPLY_PROP_TIME_TO_FULL_AVG,
56.        POWER_SUPPLY_PROP_TYPE,
57.        POWER_SUPPLY_PROP_SCOPE,
58.       
59.        POWER_SUPPLY_PROP_USB_HC,
60.        POWER_SUPPLY_PROP_USB_OTG,
61.        POWER_SUPPLY_PROP_CHARGE_ENABLED,
62.       
63.        POWER_SUPPLY_PROP_CHARGE_COUNTER_EXT,
64.       
65.        POWER_SUPPLY_PROP_MODEL_NAME,
66.        POWER_SUPPLY_PROP_MANUFACTURER,
67.        POWER_SUPPLY_PROP_SERIAL_NUMBER,
68. };

4.向具体的PSY driver提供的API

power supply class 首要任务，是向PSY driver提供统一的驱动编程接口，主要包括：

1.PSY 的register/unregister API

在driver/power/power_supply_core.c中

1. extern int power_supply_register(struct device *parent,
2.                                struct power_supply *psy);
3. extern void power_supply_unregister(struct power_supply *psy);
4. extern int power_supply_powers(struct power_supply *psy, struct device *dev);

 2.PSY状态改变时通知power supply core的API

extern void power_supply_changed(struct power_supply *psy);

当PSY driver检测到该设备某些属性改变时，需要调用这个接口(power_supply_changed(struct power_supply *psy))，通知power supply core，power supply core会有如下动作

如果该PSY是其他PSY的供电源，调用这些PSY的external_power_changed回调函数，通知他们（这些PSY具体要做什么，由他们自身的逻辑决定）；

发生notifier通知那些关心PSY设备状态的drivers；

以统一的格式向用户空间发送uevent。（这就是设备模型中class的魅力，对外接口由class core提供，可以节省driver的工作量，同时确保了接口的一致性）。

3.其他杂项接口

1. extern struct power_supply *power_supply_get_by_name(const char *name); //通过名字获取PSY指针
2. extern int power_supply_am_i_supplied(struct power_supply *psy);//查询自己是否由其他PSY供电
3. extern int power_supply_set_battery_charged(struct power_supply *psy);//调用指定的PSY的set_changed回调。
4. extern int power_supply_is_system_supplied(void); //检查系统中是否有有效的或者处于online状态的PSY，如果没有，可能为桌面系统、
6. extern int power_supply_powers(struct power_supply *psy, struct device *dev);//在指定的设备的sysfs目录下创建指定的PSY符合连接。

5.向用户空间提供的API

power supply class通过两种形式向用户空间提供接口。

  1）uevent，以“名字=value”的形式，上报所有property的值，格式如下：

1. POWER_SUPPLY_NAME=xxx                    
2. POWER_SUPPLY_xxx1=xxx                      
3. POWER_SUPPLY_xxx2=xxx

uevent一般会在PSY设备添加到kernel时，或者PSY属性发生改变时发生。

   2）sysfs，power supply class在power_supply_sysfs.c中，定义了相当多的默认attribute，如果某个PSY设备具有某个属性，该属性对应的attribute就会体现在sysfs中（一般位于“/sys/class/power_supply/xxx/”中）

2. static struct device_attribute power_supply_attrs[] = {
3.       
4.        POWER_SUPPLY_ATTR(status),
5.        POWER_SUPPLY_ATTR(charge_type),
6.        POWER_SUPPLY_ATTR(health),
7.        POWER_SUPPLY_ATTR(present),
8.        POWER_SUPPLY_ATTR(online),
9.        POWER_SUPPLY_ATTR(authentic),
10.        POWER_SUPPLY_ATTR(technology),
11.        POWER_SUPPLY_ATTR(cycle_count),
12.        POWER_SUPPLY_ATTR(voltage_max),
13.        POWER_SUPPLY_ATTR(voltage_min),
14.        POWER_SUPPLY_ATTR(voltage_max_design),
15.        POWER_SUPPLY_ATTR(voltage_min_design),
16.        POWER_SUPPLY_ATTR(voltage_now),
17.        POWER_SUPPLY_ATTR(voltage_avg),
18.        POWER_SUPPLY_ATTR(voltage_ocv),
19.        POWER_SUPPLY_ATTR(current_max),
20.        POWER_SUPPLY_ATTR(current_now),
21.        POWER_SUPPLY_ATTR(current_avg),
22.        POWER_SUPPLY_ATTR(power_now),
23.        POWER_SUPPLY_ATTR(power_avg),
24.        POWER_SUPPLY_ATTR(charge_full_design),
25.        POWER_SUPPLY_ATTR(charge_empty_design),
26.        POWER_SUPPLY_ATTR(charge_full),
27.        POWER_SUPPLY_ATTR(charge_empty),
28.        POWER_SUPPLY_ATTR(charge_now),
29.        POWER_SUPPLY_ATTR(charge_avg),
30.        POWER_SUPPLY_ATTR(charge_counter),
31.        POWER_SUPPLY_ATTR(constant_charge_current),
32.        POWER_SUPPLY_ATTR(constant_charge_current_max),
33.        POWER_SUPPLY_ATTR(constant_charge_voltage),
34.        POWER_SUPPLY_ATTR(constant_charge_voltage_max),
35.        POWER_SUPPLY_ATTR(charge_control_limit),
36.        POWER_SUPPLY_ATTR(charge_control_limit_max),
37.        POWER_SUPPLY_ATTR(energy_full_design),
38.        POWER_SUPPLY_ATTR(energy_empty_design),
39.        POWER_SUPPLY_ATTR(energy_full),
40.        POWER_SUPPLY_ATTR(energy_empty),
41.        POWER_SUPPLY_ATTR(energy_now),
42.        POWER_SUPPLY_ATTR(energy_avg),
43.        POWER_SUPPLY_ATTR(capacity),
44.        POWER_SUPPLY_ATTR(capacity_alert_min),
45.        POWER_SUPPLY_ATTR(capacity_alert_max),
46.        POWER_SUPPLY_ATTR(capacity_level),
47.        POWER_SUPPLY_ATTR(temp),
48.        POWER_SUPPLY_ATTR(temp_alert_min),
49.        POWER_SUPPLY_ATTR(temp_alert_max),
50.        POWER_SUPPLY_ATTR(temp_ambient),
51.        POWER_SUPPLY_ATTR(temp_ambient_alert_min),
52.        POWER_SUPPLY_ATTR(temp_ambient_alert_max),
53.        POWER_SUPPLY_ATTR(time_to_empty_now),
54.        POWER_SUPPLY_ATTR(time_to_empty_avg),
55.        POWER_SUPPLY_ATTR(time_to_full_now),
56.        POWER_SUPPLY_ATTR(time_to_full_avg),
57.        POWER_SUPPLY_ATTR(type),
58.        POWER_SUPPLY_ATTR(scope),
59.       
60.        POWER_SUPPLY_ATTR(usb_hc),
61.        POWER_SUPPLY_ATTR(usb_otg),
62.        POWER_SUPPLY_ATTR(charge_enabled),
63.       
64.        POWER_SUPPLY_ATTR(charge_counter_ext),
65.       
66.        POWER_SUPPLY_ATTR(model_name),
67.        POWER_SUPPLY_ATTR(manufacturer),
68.        POWER_SUPPLY_ATTR(serial_number),
69. };

6.怎样基于power supply class编写PSY driver

最后从PSY driver的角度，说明一下怎么基于power supply class编写驱动：

（1）根据硬件spec，确定PSY设备具备哪些特性，并把他们和enum power_supply_property对应。

（2）根据实际情况，实现这些properties的get/set接口。

（3）定义一个struct power_supply 变量，并初始化必要字段后，调用power_supply_register或者power_supply_register_no_ws，将其注册到kernel中。

（4）根据实际情况，启动设备属性变化的监控逻辑，例如中断，轮询等，并在发生改变时，调用power_supply_changed，通知power suopply core。

power supply子系统的引入

以市面上一款常见的的平板方案来看一看，进入平板的sys/class/power_supply/目录下

可以看到这里有三个PSY设备，分别对应USB充电器 DC充电器，和电池。

进入battery目录下，发现下面有各种各样的属性，另外两个atc260x-usb 、atc260x-wall目录下分别也是这样。

那么在内核中肯定有三个驱动对应这个三个PSY设备。

PSY设备驱动分析

我们先以battery驱动为例来分析。

1. static int __init atc260x_gauge_init(void)
2. {
3.        struct device_node *node =
4.               of_find_compatible_node(NULL, NULL, "actions,atc2603c-battery");//获取设备树中对应的属性节点
5.        if (!node) {
6.               GAUGE_INFO("%s fail to find atc2603c-battery noden", __func__);
7.               return 0;
8.        }
9.        GAUGE_INFO("atc2603c_battery:version(%s), time stamp(%s)n",
10.               ATC2603C_BATTERY_DRV_VERSION, ATC2603C_BATTERY_DRV_TIMESTAMP);
11.        return platform_driver_register(&atc260x_gauge_driver);   //将PSY设备驱动注册为platform设备驱动
12. }

看看atc260x_gauge_driver的probe函数。

2. static  int atc260x_gauge_probe(struct platform_device *pdev)
3. {
4.    struct atc260x_gauge_info *info; //
5.    int ret;
7.    info = kzalloc(sizeof(struct atc260x_gauge_info), GFP_KERNEL); //分配一个atc260x_gauge_info
8.    if (info == NULL)
9.        return -ENOMEM;
11.    info->atc260x = atc260x;
12.    info->node = pdev->dev.of_node;   //一些初始化工作
13.    global_gauge_info_ptr = info;
14.    first_store_gauge_info = 1;
16.    mutex_init(&info->lock);
18.    platform_set_drvdata(pdev, info);
19.      //这里就是power supply相关的了
20. info->battery.name = "battery";  //这name “battery”就是对应我们在/sys/class/power_supply/目录下看到的battery
21. info->battery.use_for_apm = 1;
22. info->battery.type = POWER_SUPPLY_TYPE_BATTERY; //设备type
23. info->battery.properties = atc260x_gauge_props; //设置属性列表
24. info->battery.num_properties = ARRAY_SIZE(atc260x_gauge_props); //设置属性列表的大小
25. info->battery.get_property = atc260x_gauge_get_props;  //设置获取属性值的回调函数。
26. ret = power_supply_register(&pdev->dev, &info->battery); //将这个power_supply设备注册进内核中。
27.         。。。//其他电量计相关的省略
29. return ret;

}

从上面可以看出 编写PSY driver相当的简单。就调用了一个power_supply_register函数。

后面再电量计的轮询函数中，如果检测到相关的属性发生了变化。就调用power_supply_changed函数，上报给power supply core。

1. static void soc_post_process(struct atc260x_gauge_info *info)
2. {
3.         int soc_last;
5.         if (info->soc_pre != info->soc_show) {
6.                info->soc_pre = info->soc_show;
7.                power_supply_changed(&info->battery); //如果soc发生了变化，则调用power_supply_changed上报变化信息。
8.         }
10.         info->bat_temp = get_battery_temperature();
11.         if (info->pre_temp!= info->bat_temp) {
12.                info->pre_temp = info->bat_temp;
13.                power_supply_changed(&info->battery); //如果温度发生了变化也进行上报
14.         }
15.         //省略其他不相关的。。。
16. }

对于USB 和WALL 的PSY设备，其编程方法也是类似的，这里不再赘述。

power supply framework的分析

先从power_supply_register分析起

1. int power_supply_register(struct device *parent, struct power_supply *psy)
2. {
3.         struct device *dev;
4.         int rc;
6.         dev = kzalloc(sizeof(*dev), GFP_KERNEL); //分配一个device 结构
7.         if (!dev)
8.                return -ENOMEM;
10.         device_initialize(dev);
12.         dev->class = power_supply_class;  //指定power_supply_class
13.         dev->type = &power_supply_dev_type; //指定设备类型
14.         dev->parent = parent;               //指定此设备的父设备  
15.         dev->release = power_supply_dev_release;
16.         dev_set_drvdata(dev, psy);
17.         psy->dev = dev;
19.         INIT_WORK(&psy->changed_work, power_supply_changed_work); //初始化一个power_supply_changed_work 工做队列
21.         rc = power_supply_check_supplies(psy);
22.         if (rc) {
23.                dev_info(dev, "Not all required supplies found, defer proben");
24.                goto check_supplies_failed;
25.         }
27.         rc = kobject_set_name(&dev->kobj, "%s", psy->name);  //设置kobject的name，其实就是“battery”
28.         if (rc)
29.                goto kobject_set_name_failed;
31.         rc = device_add(dev);  //将这个设备添加到设备链表中去
32.         if (rc)
33.                goto device_add_failed;
35.         spin_lock_init(&psy->changed_lock);
36.         rc = device_init_wakeup(dev, true);
37.         if (rc)
38.                goto wakeup_init_failed;
40.         rc = psy_register_thermal(psy);
41.         if (rc)
42.                goto register_thermal_failed;
44.         rc = psy_register_cooler(psy);
45.         if (rc)
46.                goto register_cooler_failed;
48.         rc = power_supply_create_triggers(psy);
49.         if (rc)
50.                goto create_triggers_failed;
52.         power_supply_changed(psy); //调用一次changed，上报一次属性值
54.         goto success;
55. }

接着看看power_supply_changed

1. void power_supply_changed(struct power_supply *psy)
2. {
3.         unsigned long flags;
5.         dev_dbg(psy->dev, "%sn", __func__);
7.         spin_lock_irqsave(&psy->changed_lock, flags);
8.         psy->changed = true;
9.         pm_stay_awake(psy->dev);
10.         spin_unlock_irqrestore(&psy->changed_lock, flags);
11. schedule_work(&psy->changed_work); //将psy->changed_work任务提交到工做队列，这个工做队列就是在power_supply_register中初始化的
12. }
13. EXPORT_SYMBOL_GPL(power_supply_changed);

既然如此，那我们就应该继续去看psy->changed_work的工作队列函数。power_supply_changed_work​​​​​​​

1. static void power_supply_changed_work(struct work_struct *work)
2. {
3.         unsigned long flags;
4.         struct power_supply *psy = container_of(work, struct power_supply, //获取到PSY
5.                                               changed_work);
7.         dev_dbg(psy->dev, "%sn", __func__);
9.         spin_lock_irqsave(&psy->changed_lock, flags);
10.         if (psy->changed) {                    //已经在power_supply_changed中被设置成true了。
11.                psy->changed = false;
12.                spin_unlock_irqrestore(&psy->changed_lock, flags);
14.                class_for_each_device(power_supply_class, NULL, psy,
15.                                      __power_supply_changed_work);
17.                power_supply_update_leds(psy);          //更改led指示状态
19.                kobject_uevent(&psy->dev->kobj, KOBJ_CHANGE); //发送uevent事件，通知应用层
20.                spin_lock_irqsave(&psy->changed_lock, flags);
21.         }
22.         if (!psy->changed)
23.                pm_relax(psy->dev);
24.         spin_unlock_irqrestore(&psy->changed_lock, flags);
25. }

至此，每当驱动中计算出battery的电量信息发生了变化，或者充电器的插拔状态发生了变化，驱动都会调用power_supply_changed函数，随后在power_supply_changed中会启动工作队列，上报uevent事件，通知Android层去sysfs中读取电池相关的属性信息，展现给用户空间。

/drivers/power/supply/qcom/qpnp-smb5.c   charger driver

/drivers/power/supply/qcom/smb5-lib.c     依赖的SMB library

/arch/arm64/boot/dts/qcom/pmi632.dtsi     dtsi

高通平台power_supply 框架下添加第三方充电IC的驱动方法

原文链接：https://blog.csdn.net/stoic163/article/details/99680422

1.power_supply电源框架介绍：

power supply framework在kernel/drivers/power/下。内核抽象出来power supply子系统为驱动提供了统一的框架。

功能包括：

1.抽象PSY设备的共性，向用户空间提供统一的API；

2.为底层PSY驱动的编写，提供简单、统一的方式，同时封装并实现公共逻辑。

power supply class位于drivers/power/目录中，主要由3部分组成（可参考下图的软件架构）：

1）power_supply_core，用于抽象核心数据结构、实现公共逻辑。位于drivers/power/power_supply_core.c中。

2）power_supply_sysfs，实现sysfs以及uevent功能。位于drivers/power/power_supply_sysfs.c中。

3）power_supply_leds，基于Linux led class，提供PSY设备状态指示的通用实现。位于drivers/power/power_suppply_leds.c中。

最后，驱动工程师可以基于power supply class，实现具体的PSY drivers，主要处理平台相关、硬件相关的逻辑。这些drivers都位于drivers/power/power_supply目录下。

在具体设备文件中在/sys/class/power_supply,具体如下：

power_supply 框架工作流程

Linux的设备文件目录中可以在sys/class/下看到power_supply目录；这个power_supply的类是通过power_supply_core.c文件中的power_supply_class_init()中的class_create()函数来进行power_supply类的创建，如下：

进入power_supply的目录下：

我们可以看到出现了battery与usb两个目录，这两个目录就是充电IC(battery)与USB(usb)电源管理部分的注册的设备节点内容的集合。

进入battery目录下:

可以看到很多设备节点，这些节点就是通过power_supply的电源框架提供的方法进行注册并实现其内容的。

对于上述的节点内容，是怎么实现的，其实power_supply都提供了相应的节点名称，在文件/kernel/include/linux/power_supply.h中提供了相关的属性枚举定义。如下：

这里提供了大部分的设备节点属性。作为驱动工程师，只需要选取芯片存在的并且自己需要的属性并实现其内容即可。

在power_supply的结构体中(也可能是在结构体之外)：

在这个结构体中，可以看到有set_property与get_property两个属性的函数指针，这两个函数指针就是用来具体实现相关属性功能的。

power_supply_sysfy文件系统

power_supply_sysfs.c文件中，具体进行的是设备节点的注册过程，以及相关功能的实现：

从上面可以看出，在power_supply_sysfs文件中主要是实现power_supply_attrs数组中的成员的show与store。

先看power_supply_attrs数组：

从上述内容看，power_supply_attrs数组其实就是实现之前power_supply.h文件中的枚举power_supply_property。而POWER_SUPPLY_ATTR(online)中括号内容即是具体设备节点。​​​​​​​

在POWER_SUPPLY_ATTR结构体中，有show与store两个指针。

show的内容就是使用cat  xxxx节点的操作显示出来的内容的：

从上面可以看到有些节点显示的内容并不是数字，而是在show函数中被转换成了相关的字符串。如:

而store函数是echo xx > xxx节点的操作写入的内容。

在上述节点中，存在uevent这个节点，可以看看uevent节点的内容：

这个节点由power_supply_sysfs文件中的power_supply_uevent函数实现的。

这个函数的作用就是将该设备节点下所有节点的内容组合成字符串发送到uevent中，在通过内核的uevent框架发送到用户空间。

当设备节点内容发生变化时，会调用power_supply_changed函数：

可以看到该函数是将psy->changed_work加入到工作队列中，具体的调用设备的changed_work的工作队列，看看具体做什么：

可以看到，对该类中查询每个设备的更新操作，再更新led灯的操作，还有就是发送新的事件(uevent)通知应用层。

至此power_supply就介绍结束了。