Power Supply 模块分析

┌─────────────────────────────────────────────────────────┐
│          Android Framework (BatteryService)             │
└────────────────────┬────────────────────────────────────┘
                     │ /sys/class/power_supply/
┌────────────────────┴────────────────────────────────────┐
│         Linux Power Supply Framework (内核标准)          │
└────────────────────┬────────────────────────────────────┘
                     │ power_supply_register()
┌────────────────────┴────────────────────────────────────┐
│          power_supply Module (适配层) ← 当前模块         │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐             │
│  │ Battery  │  │   USB    │  │ Wireless │  ...        │
│  └────┬─────┘  └────┬─────┘  └────┬─────┘             │
└───────┼─────────────┼─────────────┼────────────────────┘
        │             │             │ power_supply_ops_register()
┌───────┴─────────────┴─────────────┴────────────────────┐
│      Hardware Drivers (coul/charger/wireless)          │
└─────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────┐
│  Layer 3: Application (power_supply_application.c)     │
│  • power_supply_app_get_bat_capacity()                 │
│  • power_supply_app_get_bat_temp()                     │
│  • power_supply_app_get_usb_voltage_now()              │
│  作用：为其他内核模块提供便捷访问接口                    │
└────────────────────┬────────────────────────────────────┘
                     │
┌────────────────────┴────────────────────────────────────┐
│  Layer 2: Interface (power_supply_interface.c)         │
│  • power_supply_get_int_property_value()               │
│  • power_supply_set_int_property_value()               │
│  • power_supply_sync_changed()                         │
│  作用：封装标准power_supply接口，简化调用               │
└────────────────────┬────────────────────────────────────┘
                     │
┌────────────────────┴────────────────────────────────────┐
│  Layer 1: Core (power_supply.c)                        │
│  • power_supply_ops_register()                         │
│  • power_supply_battery_get_property()                 │
│  • power_supply_register_power_supply()                │
│  作用：核心适配层，连接Linux框架和硬件驱动               │
└─────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────┐
│  读取电池电量流程示例                                     │
└─────────────────────────────────────────────────────────┘

1. Android层读取
   cat /sys/class/power_supply/Battery/capacity
        ↓
2. Linux power_supply框架
   power_supply_show_property()
        ↓
3. power_supply核心层
   power_supply_cust_bat_get_property(POWER_SUPPLY_PROP_CAPACITY)
        ↓
4. 根据属性类型调用
   power_supply_get_capacity_property(POWER_SUPPLY_PROP_BAT)
        ↓
5. 查找已注册的ops
   power_supply_get_ops(POWER_SUPPLY_PROP_BAT)
        ↓
6. 调用底层驱动回调
   l_ops->get_capacity_prop()  // 由coul驱动注册
        ↓
7. 返回电量值
   return 85;  // 85%

struct power_supply_ops {
    const char *type_name;  // 类型名称："bat"/"usb"/"wireless"等
    
    // 状态相关属性（20+回调函数）
    int (*get_status_prop)(void);          // 充电状态
    int (*get_health_prop)(void);          // 健康状态
    int (*get_present_prop)(void);         // 是否在位
    int (*get_online_prop)(void);          // 是否在线
    int (*get_technology_prop)(void);      // 电池技术类型
    
    // 温度和循环
    int (*get_temp_prop)(void);            // 温度
    int (*get_cycle_count_prop)(void);     // 循环次数
    int (*get_limit_fcc_prop)(void);       // FCC限制
    
    // 电压相关
    int (*get_voltage_now_prop)(void);     // 当前电压
    int (*get_voltage_max_prop)(void);     // 最大电压
    int (*get_voltage_max_design_prop)(void); // 设计最大电压
    int (*set_voltage_max_prop)(int value); // 设置最大电压（可写）
    
    // 电流相关
    int (*get_current_now_prop)(void);     // 当前电流
    int (*get_current_max_prop)(void);     // 最大电流
    int (*get_current_avg_prop)(void);     // 平均电流
    int (*get_input_current_limit_prop)(void); // 输入电流限制
    int (*set_input_current_limit_prop)(int value); // 设置输入限流
    
    // 容量相关
    int (*get_capacity_prop)(void);        // 百分比电量
    int (*get_capacity_level_prop)(void);  // 电量等级
    int (*get_capacity_rm_prop)(void);     // 剩余容量(mAh)
    int (*get_capacity_fcc_prop)(void);    // 满充容量(mAh)
    
    // 充电量相关
    int (*get_charge_full_prop)(void);     // 充满电量
    int (*get_charge_counter_prop)(void);  // 电量计数器
    int (*get_charge_full_design_prop)(void); // 设计容量
    int (*get_charge_now_prop)(void);      // 当前电量
    
    // 其他
    int (*get_batid_prop)(void);           // 电池ID
    const char *(*get_brand_prop)(void);   // 电池品牌
    int (*get_type_prop)(void);            // 类型
    int (*get_usb_type_prop)(void);        // USB类型
};

struct power_supply_dev {
    struct device *dev;               // 平台设备
    struct device_node *np;           // DTS节点
    
    // 6种power_supply实例
    struct power_supply *bat;         // 主电池 (Battery)
    struct power_supply *raw_bat;     // 原始电池 (battery/huawei_batt)
    struct power_supply *assist_bat;  // 辅助电池 (assist_battery)
    struct power_supply *mains;       // 市电 (Mains)
    struct power_supply *usb;         // USB充电 (usb/USB)
    struct power_supply *wireless;    // 无线充电 (Wireless)
    
    // 配置标志（通过DTS配置）
    int support_bat;                  // 是否支持主电池（默认1）
    int support_raw_bat;              // 是否支持原始电池（默认0）
    int support_assist_bat;           // 是否支持辅助电池（默认0）
    int support_mains;                // 是否支持市电（默认0）
    int support_usb;                  // 是否支持USB（默认0）
    int support_wireless;             // 是否支持无线充电（默认0）
    
    enum power_supply_bat_mode bat_mode; // 电池模式
    unsigned int total_ops;           // 已注册的ops数量
    struct power_supply_ops *p_ops[POWER_SUPPLY_PROP_END]; // ops数组
};

enum power_supply_prop_type {
    POWER_SUPPLY_PROP_BEGIN = 0,
    POWER_SUPPLY_PROP_BAT = 0,        // 主电池（自定义逻辑）
    POWER_SUPPLY_PROP_RAW_BAT,        // 原始电池（底层真实数据）
    POWER_SUPPLY_PROP_ASSITST_BAT,    // 辅助电池（双电池方案）
    POWER_SUPPLY_PROP_MAINS,          // 市电（AC充电器）
    POWER_SUPPLY_PROP_USB,            // USB充电
    POWER_SUPPLY_PROP_WIRELESS,       // 无线充电
    POWER_SUPPLY_PROP_END,
};

int power_supply_ops_register(struct power_supply_ops *ops)
{
    int type;
    
    // 1. 参数检查
    if (!g_power_supply_dev || !ops || !ops->type_name)
        return -EPERM;

    // 2. 根据类型名查找类型ID
    type = power_supply_get_prop_type(ops->type_name);
    // "bat" -> POWER_SUPPLY_PROP_BAT
    // "usb" -> POWER_SUPPLY_PROP_USB
    
    if (type < 0)
        return -EPERM;

    // 3. 注册到全局ops数组
    g_power_supply_dev->p_ops[type] = ops;
    g_power_supply_dev->total_ops++;

    hwlog_info("total_ops=%d type=%d:%s ops register ok\n",
        g_power_supply_dev->total_ops, type, ops->type_name);
    return 0;
}

static int coul_get_capacity(void)
{
    return coul_drv_battery_capacity();  // 读取电量计数据
}

static int coul_get_voltage_now(void)
{
    return coul_drv_battery_voltage();
}

static struct power_supply_ops coul_bat_ops = {
    .type_name = "bat",
    .get_capacity_prop = coul_get_capacity,
    .get_voltage_now_prop = coul_get_voltage_now,
    .get_temp_prop = coul_get_temp,
    // ... 其他回调
};

static int coul_probe(struct platform_device *pdev)
{
    // ...
    power_supply_ops_register(&coul_bat_ops);  // 注册电池ops
    return 0;
}

static int power_supply_cust_bat_get_property(struct power_supply *psy,
    enum power_supply_property psp, union power_supply_propval *val)
{
    struct power_supply_dev *l_dev = power_supply_get_dev();

    // 如果是透传模式，直接读取底层battery节点
    if (l_dev->bat_mode == POWER_SUPPLY_BAT_BYPASS_MODE)
        return power_supply_get_property_value("battery", psp, val);

    // 否则调用注册的回调
    return power_supply_battery_get_property(POWER_SUPPLY_PROP_BAT,
        psp, val);
}

static int power_supply_battery_get_property(int type,
    enum power_supply_property psp, union power_supply_propval *val)
{
    switch (psp) {
    case POWER_SUPPLY_PROP_CAPACITY:
        // 1. 获取已注册的ops
        struct power_supply_ops *l_ops = power_supply_get_ops(type);
        
        // 2. 检查回调是否存在
        if (!l_ops || !l_ops->get_capacity_prop)
            return POWER_SUPPLY_DEFAULT_CAPACITY;  // 返回默认值50
        
        // 3. 调用底层驱动回调
        val->intval = l_ops->get_capacity_prop();
        break;
    
    // ... 其他22个属性的处理
    }
    return 0;
}

static int power_supply_register_power_supply(struct power_supply_dev *l_dev)
{
    // 根据DTS配置注册不同的power_supply设备
    
    if (l_dev->support_bat) {
        l_dev->bat = power_supply_register(l_dev->dev,
            &power_supply_battery_desc, NULL);
        // 注册 /sys/class/power_supply/Battery
    }

    if (l_dev->support_raw_bat) {
        l_dev->raw_bat = power_supply_register(l_dev->dev,
            &power_supply_raw_battery_desc, NULL);
        // 注册 /sys/class/power_supply/battery 或 huawei_batt
    }

    if (l_dev->support_usb) {
        l_dev->usb = power_supply_register(l_dev->dev,
            &power_supply_usb_desc, NULL);
        // 注册 /sys/class/power_supply/usb
    }

    // ... 类似处理 assist_bat/mains/wireless
    
    return 0;
}

/sys/class/power_supply/
├── Battery/          # 主电池（Android读取此节点）
│   ├── capacity      # 电量百分比
│   ├── voltage_now   # 当前电压
│   ├── current_now   # 当前电流
│   ├── temp          # 温度
│   └── status        # 充电状态
├── battery/          # 原始电池（调试用）
├── assist_battery/   # 辅助电池（双电池）
├── usb/              # USB充电器
│   ├── online        # 是否在线
│   ├── voltage_now   # USB电压
│   └── usb_type      # USB类型(SDP/DCP/PD等)
└── Wireless/         # 无线充电
    └── online

// 简化的整数属性读取
int power_supply_get_int_property_value(const char *name,
    enum power_supply_property psp, int *val)
{
    union power_supply_propval union_val = { 0 };
    
    // 1. 根据名称获取power_supply实例
    // 2. 调用标准get_property
    // 3. 提取整数值
    
    ret = power_supply_get_property_value(name, psp, &union_val);
    if (!ret)
        *val = union_val.intval;
    
    return ret;
}

// 使用示例
int capacity;
power_supply_get_int_property_value("Battery", 
    POWER_SUPPLY_PROP_CAPACITY, &capacity);
// capacity = 85

int power_supply_app_get_bat_capacity(void)
{
    struct power_supply_app_dev *l_dev = power_supply_app_get_dev();
    int val = POWER_SUPPLY_DEFAULT_CAPACITY;
    
    // 从DTS配置的电池节点名读取（默认"battery"）
    ret = power_supply_get_int_property_value(l_dev->bat_psy,
        POWER_SUPPLY_PROP_CAPACITY, &val);
    
    if (ret)
        hwlog_err("use default bat_capacity: value=%d\n", val);
    
    return val;
}

// 其他内核模块直接调用
#include <chipset_common/hwpower/common_module/power_supply_application.h>

int capacity = power_supply_app_get_bat_capacity();
int temp = power_supply_app_get_bat_temp();
int vbat = power_supply_app_get_bat_voltage_now();

// 在coul_core.c中
static int coul_get_bat_capacity(void)
{
    return coul_battery_capacity();  // 从电量计芯片读取
}

static int coul_get_bat_voltage(void)
{
    return coul_battery_voltage_uv();  // 单位：uV
}

static int coul_get_bat_current(void)
{
    return coul_battery_current_ua();  // 单位：uA
}

static int coul_get_bat_temp(void)
{
    return coul_battery_temperature();  // 单位：0.1°C
}

static struct power_supply_ops coul_bat_ops = {
    .type_name = "bat",  // 注册为主电池
    .get_capacity_prop = coul_get_bat_capacity,
    .get_voltage_now_prop = coul_get_bat_voltage,
    .get_current_now_prop = coul_get_bat_current,
    .get_temp_prop = coul_get_bat_temp,
    .get_health_prop = coul_get_bat_health,
    .get_status_prop = coul_get_charge_status,
    // ... 其他属性
};

static int coul_probe(struct platform_device *pdev)
{
    int ret;
    
    // 初始化电量计硬件
    ret = coul_hardware_init();
    if (ret)
        return ret;
    
    // 注册到power_supply框架
    ret = power_supply_ops_register(&coul_bat_ops);
    if (ret)
        hwlog_err("register bat ops fail\n");
    
    return ret;
}

// 在charger.c中
static int charger_get_usb_online(void)
{
    return charge_get_charger_online();  // 检测充电器是否插入
}

static int charger_get_usb_voltage(void)
{
    return charge_get_vbus();  // 读取VBUS电压
}

static int charger_get_usb_type(void)
{
    int type = charge_get_charger_type();
    
    // 转换为标准USB类型
    switch (type) {
    case CHARGER_TYPE_SDP:
        return POWER_SUPPLY_USB_TYPE_SDP;
    case CHARGER_TYPE_DCP:
        return POWER_SUPPLY_USB_TYPE_DCP;
    case CHARGER_TYPE_PD:
        return POWER_SUPPLY_USB_TYPE_PD;
    default:
        return POWER_SUPPLY_USB_TYPE_UNKNOWN;
    }
}

static int charger_set_input_current_limit(int value)
{
    return charge_set_input_current(value / 1000);  // uA -> mA
}

static struct power_supply_ops charger_usb_ops = {
    .type_name = "usb",
    .get_online_prop = charger_get_usb_online,
    .get_voltage_now_prop = charger_get_usb_voltage,
    .get_usb_type_prop = charger_get_usb_type,
    .set_input_current_limit_prop = charger_set_input_current_limit,
};

static int charger_probe(struct platform_device *pdev)
{
    // ...
    power_supply_ops_register(&charger_usb_ops);
    return 0;
}

# Android层通过sysfs读取

# 读取电量
adb shell cat /sys/class/power_supply/Battery/capacity
# 输出：85

# 读取电压
adb shell cat /sys/class/power_supply/Battery/voltage_now
# 输出：4200000  (4.2V，单位uV)

# 读取温度
adb shell cat /sys/class/power_supply/Battery/temp
# 输出：350  (35°C，单位0.1°C)

# 读取充电状态
adb shell cat /sys/class/power_supply/Battery/status
# 输出：Charging / Discharging / Full / Not charging

# 读取USB类型
adb shell cat /sys/class/power_supply/usb/usb_type
# 输出：USB_PD  (支持PD快充)

// 在无线充电驱动中
#include <chipset_common/hwpower/common_module/power_supply_application.h>

static void wldc_check_battery_state(void)
{
    int capacity, temp, vbat;
    
    // 使用简化接口读取电池信息
    capacity = power_supply_app_get_bat_capacity();
    temp = power_supply_app_get_bat_temp();  // 自动转换为°C
    vbat = power_supply_app_get_bat_voltage_now();  // 自动转换为mV
    
    hwlog_info("battery: capacity=%d%%, temp=%d°C, vbat=%dmV\n",
        capacity, temp, vbat);
    
    // 根据电池状态调整无线充电功率
    if (temp > 45)
        wldc_set_power_limit(50);  // 高温降功率
    else if (capacity > 90)
        wldc_set_power_limit(30);  // 接近充满降功率
}

// 设备树配置
power_supply: power_supply {
    compatible = "huawei,power_supply";
    
    // 配置启用的电源类型
    support_bat = <1>;         // 启用主电池
    support_raw_bat = <0>;     // 禁用原始电池
    support_assist_bat = <1>;  // 启用辅助电池（双电池）
    support_mains = <0>;       // 禁用市电
    support_usb = <1>;         // 启用USB
    support_wireless = <1>;    // 启用无线充电
    
    // 电池模式
    bat_mode = <0>;  // 0=注册模式, 1=透传模式
};

power_supply_app: power_supply_app {
    compatible = "huawei,power_supply_app";
    
    // 配置电池节点名（平台相关）
    bat_psy_name = "battery";  // 或 "Battery"
    usb_psy_name = "usb";      // 或 "USB"
};

# 查看已注册的power_supply设备
ls /sys/class/power_supply/
# 期望输出：Battery  battery  assist_battery  usb  Wireless

# 查看设备类型
cat /sys/class/power_supply/Battery/type
# 输出：Battery

cat /sys/class/power_supply/usb/type
# 输出：USB

# 检查内核日志
dmesg | grep "power_psy\|power_supply"
# 期望输出：
# [   10.123] power_psy: total_ops=1 type=0:bat ops register ok
# [   10.234] power_psy: total_ops=2 type=4:usb ops register ok
# [   10.345] power_psy: total_ops=3 type=5:wireless ops register ok

# 批量读取所有电池属性
cd /sys/class/power_supply/Battery
for prop in *; do
    echo "=== $prop ==="
    cat "$prop" 2>&1
done

# 输出示例：
# === capacity ===
# 85
# === voltage_now ===
# 4200000
# === current_now ===
# -500000  (负数表示放电)
# === temp ===
# 350  (35°C)
# === status ===
# Charging

# 设置USB输入限流（需要内核5.4+）
echo 1000000 > /sys/class/power_supply/usb/input_current_limit
# 限制输入电流为1A

# 设置辅助电池最大电压
echo 4350000 > /sys/class/power_supply/assist_battery/voltage_max
# 设置为4.35V

# 检查是否生效
cat /sys/class/power_supply/usb/input_current_limit
# 输出：1000000

// 在驱动中添加调试信息
static int coul_get_bat_capacity(void)
{
    int capacity = coul_battery_capacity();
    
    // 添加详细日志
    hwlog_info("[PSY_DEBUG] get_capacity called, value=%d\n", capacity);
    
    return capacity;
}

// 查看调用日志
dmesg -w | grep PSY_DEBUG
# [  123.456] coul: [PSY_DEBUG] get_capacity called, value=85

power_supply 模块依赖：
├── Linux power_supply框架  --> 标准内核接口
├── power_dts.h            --> DTS解析
├── power_event_ne.h       --> 事件通知（可选）
└── power_printk.h         --> 日志打印

┌─────────────────────────────────────────────────────┐
│  Android Java层 (BatteryService)                   │
│  frameworks/base/services/core/java/com/android/   │
│  server/BatteryService.java                        │
└────────────────────┬────────────────────────────────┘
                     │ JNI
┌────────────────────┴────────────────────────────────┐
│  Android Native层 (BatteryMonitor)                 │
│  system/core/healthd/BatteryMonitor.cpp            │
│  读取 /sys/class/power_supply/Battery/*            │
└────────────────────┬────────────────────────────────┘
                     │ sysfs
┌────────────────────┴────────────────────────────────┐
│  Linux power_supply框架                             │
│  drivers/power/supply/power_supply_sysfs.c         │
└────────────────────┬────────────────────────────────┘
                     │ get_property()
┌────────────────────┴────────────────────────────────┐
│  power_supply模块 (适配层)                          │
│  drivers/hwpower/cc_common_module/power_supply/    │
└────────────────────┬────────────────────────────────┘
                     │ ops回调
┌────────────────────┴────────────────────────────────┐
│  coul/charger等硬件驱动                             │
└─────────────────────────────────────────────────────┘

RAW_BAT读取：capacity = 87%  (硬件返回值)
BAT显示：   capacity = 85%  (应用平滑算法后)

┌──────────────┐
│   主屏幕     │  ← 主电池 (4000mAh)
├──────────────┤
│   副屏幕     │  ← 辅助电池 (4000mAh)
└──────────────┘
总容量：8000mAh

#if (LINUX_VERSION_CODE >= KERNEL_VERSION(5, 4, 0))
    // 新版本：支持完整USB属性
    static enum power_supply_property power_supply_usb_props[] = {
        POWER_SUPPLY_PROP_ONLINE,
        POWER_SUPPLY_PROP_VOLTAGE_NOW,
        POWER_SUPPLY_PROP_USB_TYPE,  // 新增
        POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT,  // 新增（可写）
        // ...
    };
#else
    // 旧版本：仅支持online
    static enum power_supply_property power_supply_usb_props[] = {
        POWER_SUPPLY_PROP_ONLINE,
    };
#endif

// 传统方式（复杂）
struct power_supply *psy;
union power_supply_propval val;
psy = power_supply_get_by_name("Battery");
power_supply_get_property(psy, POWER_SUPPLY_PROP_CAPACITY, &val);
int capacity = val.intval;
power_supply_put(psy);

// 应用层接口（简化）
int capacity = power_supply_app_get_bat_capacity();

// 不推荐：在循环中频繁读取
for (i = 0; i < 1000; i++) {
    int vbat = power_supply_app_get_bat_voltage_now();
    // 每次都触发I2C读取
}

// 推荐：缓存读取结果
static int g_cached_vbat;
static unsigned long g_cache_time;

int get_bat_voltage_cached(void)
{
    unsigned long now = jiffies;
    
    // 100ms内使用缓存值
    if (time_before(now, g_cache_time + msecs_to_jiffies(100)))
        return g_cached_vbat;
    
    g_cached_vbat = power_supply_app_get_bat_voltage_now();
    g_cache_time = now;
    return g_cached_vbat;
}

// 推荐：一次读取多个属性（减少锁竞争）
struct power_supply *psy = power_supply_get_by_name("Battery");
union power_supply_propval val;

power_supply_get_property_value_with_psy(psy, POWER_SUPPLY_PROP_CAPACITY, &val);
int capacity = val.intval;

power_supply_get_property_value_with_psy(psy, POWER_SUPPLY_PROP_VOLTAGE_NOW, &val);
int voltage = val.intval;

power_supply_put(psy);

华为电源管理子系统模块定位：

基础设施层：
├── power_sysfs      --> sysfs节点管理
├── power_supply     --> 电源设备抽象 ← 当前模块
├── power_event      --> 事件通知
├── power_vote       --> 参数仲裁
├── power_dsm        --> 异常上报
└── power_log        --> 日志收集

业务功能层：
├── coul             --> 电量计驱动（注册bat ops）
├── charger          --> 充电器驱动（注册usb ops）
├── wireless_charger --> 无线充电（注册wireless ops）
└── direct_charge    --> 直充驱动（读取bat属性）