[灵感风暴] Charger Property Engine 设计方案

// 获取当前的显著变化（delta）和噪声估计值
delta = abs(current_value - previous_value);
noise = calculate_noise_estimate();

// 计算当前的门限（阈值），根据噪声门限和窗口振幅动态调整
eps = max(abs_eps_floor, k_noise * noise);
range = calculate_window_range();

// 判断是否为显著变化
if (delta > eps || range > range_eps_floor) {
    // 显著变化：加速刷新，缩短 TTL
    ttl = max(min_ttl, ttl / 2);  // 缩短 TTL
    stable_count = 0;  // 重置稳定计数
} else {
    // 稳定状态：延长 TTL，减少刷新频率
    stable_count++;
    if (stable_count >= 3) {  // 3次稳定才延长TTL
        ttl = min(max_ttl, ttl + (ttl / 2));  // 延长 TTL
    }
}

// 更新缓存
update_cache(ttl, current_value);

// 更新噪声估计（采用EWMA）
noise = (current_delta - noise) / 8 + noise;

// 计算当前的噪声门限
eps = max(abs_eps_floor, k_noise * noise);

// 检测变化是否显著
if (abs(current_value - previous_value) > eps) {
    // 发生显著变化
    update_cache(current_value);
}

// 更新滑动窗口
push_to_window(current_value);

// 计算窗口振幅
range = window_max - window_min;

// 如果振幅超过阈值，认为是显著变化
if (range > range_eps_floor) {
    // 发生显著变化
    update_cache(current_value);
}

/// 定义需要加入到引擎的属性
enum charger_property_props {
    CHG_PROP_STATUS = 0;
    CHG_PROP_CURRENT;
    CHG_PROP_VOLTAGE;
    CHG_PROP_TEMP;
    //...
};

// 将引擎接口插入到charger device里
struct charger_device {
    struct device *device;
    //...
    struct prop_engine *pe;
    //...
};

static struct prop_engine *g_charger_pe = NULL;   /// 全局静态变量，供稳定性用trace32 debug

// 在charger_probe中
static int charger_probe(struct i2c_client *client)
{
    struct charger_device *chg;

    /* ... 原有代码 ... */

    /* 创建Property Engine */
    chg->pe = pe_create("charger_property_engine", &client->dev, chg,
                       &charger_pe_ops, charger_prop_descs,
                       ARRAY_SIZE(charger_prop_descs));
    g_charger_pe = chg->pe;

    /* 设置日志级别（可选） */
    pe_set_log_level(chg->pe, PE_LOG_DEBUG);  // 最高级别，记录所有日志

    /* 初始化debugfs（可选） */
#ifdef CONFIG_DEBUG_FS
    pe_debugfs_init(chg->pe);
#endif

    return 0;
}

static const struct pe_prop_desc charger_prop_descs[] = {
    /* 状态寄存器 - 快速变化 */
    [CHG_PROP_STATUS] = {
        .name = "status",
        .reg = CHG_REG_STATUS,
        .mask = 0x0F,           /* 低4位 */
        .shift = 0,
        .scale = 1,
        .offset = 0,
        .cls = PE_FAST,
        .min_ttl_ms = 100,      /* 最小100ms刷新 */
        .max_ttl_ms = 1000,     /* 最大1s刷新 */
        .k_noise = 2,
        .abs_eps_floor = 1,     /* 变化1个单位就认为显著 */
        .range_eps_floor = 3,
        .win_size = 0,          /* 状态位不需要窗口 */
        .safe_default = 0,      /* 默认状态：未知 */
        .writable = false,
        .min_req_gap_ms = 50,   /* 最小请求间隔50ms */
    },
    /* 电压 - 中等变化，0.01V/LSB */
    [CHG_PROP_VOLTAGE] = {
        .name = "voltage",
        .reg = CHG_REG_VOLTAGE,
        .mask = 0xFF,
        .shift = 0,
        .scale = 10,            /* 10mV/LSB */
        .offset = 0,
        .cls = PE_MED,
        .min_ttl_ms = 200,
        .max_ttl_ms = 5000,
        .k_noise = 3,
        .abs_eps_floor = 20,    /* 20mV变化 */
        .range_eps_floor = 50,
        .win_size = 8,          /* 8个样本窗口 */
        .safe_default = 3700,   /* 3.7V默认 */
        .writable = false,
        .min_req_gap_ms = 100,
    },
    /* 电流 - 快速变化，0.05A/LSB */
    [CHG_PROP_CURRENT] = {
        .name = "current",
        .reg = CHG_REG_CURRENT,
        .mask = 0xFF,
        .shift = 0,
        .scale = 50,            /* 50mA/LSB */
        .offset = 0,
        .cls = PE_FAST,
        .min_ttl_ms = 100,
        .max_ttl_ms = 2000,
        .k_noise = 2,
        .abs_eps_floor = 50,    /* 50mA变化 */
        .range_eps_floor = 100,
        .win_size = 8,
        .safe_default = 0,
        .writable = false,
        .min_req_gap_ms = 50,
    },
    /* 温度 - 慢速变化，0.5°C/LSB */
    [CHG_PROP_TEMP] = {
        .name = "temperature",
        .reg = CHG_REG_TEMP,
        .mask = 0xFF,
        .shift = 0,
        .scale = 5,             /* 0.5°C/LSB */
        .offset = -400,         /* 偏移-40°C */
        .cls = PE_SLOW,
        .min_ttl_ms = 1000,
        .max_ttl_ms = 30000,
        .k_noise = 4,
        .abs_eps_floor = 5,     /* 0.5°C变化 */
        .range_eps_floor = 10,
        .win_size = 16,
        .safe_default = 250,    /* 25°C默认 */
        .writable = false,
        .min_req_gap_ms = 500,
    },
    /* 故障状态 - 快速变化 */
    [CHG_PROP_FAULT_STATUS] = {
        .name = "fault_status",
        .reg = CHG_REG_FAULT,
        .mask = 0x1F,
        .shift = 0,
        .scale = 1,
        .offset = 0,
        .cls = PE_FAST,
        .min_ttl_ms = 100,
        .max_ttl_ms = 1000,
        .k_noise = 1,
        .abs_eps_floor = 0,     /* 任何变化都重要 */
        .range_eps_floor = 0,
        .win_size = 0,
        .safe_default = 0,      /* 默认无故障 */
        .writable = false,
        .min_req_gap_ms = 50,
    },
    /* 充电使能 - 静态，可写 */
    [CHG_PROP_CHARGE_ENABLE] = {
        .name = "charge_enable",
        .reg = CHG_REG_CONTROL,
        .mask = 0x01,
        .shift = 0,
        .scale = 1,
        .offset = 0,
        .cls = PE_STATIC,
        .min_ttl_ms = 1000,
        .max_ttl_ms = 60000,
        .k_noise = 0,
        .abs_eps_floor = 0,
        .range_eps_floor = 0,
        .win_size = 0,
        .safe_default = 0,
        .writable = true,
        .reg_wr = CHG_REG_CONTROL,
        .mask_wr = 0x01,
        .shift_wr = 0,
        .min_req_gap_ms = 100,
    },
    /* 终止电流 - 静态，可写 */
    [CHG_PROP_TERMINATION_CURRENT] = {
        .name = "termination_current",
        .reg = CHG_REG_TERM_CURRENT,
        .mask = 0x0F,
        .shift = 0,
        .scale = 100,           /* 100mA/LSB */
        .offset = 100,          /* 基础100mA */
        .cls = PE_STATIC,
        .min_ttl_ms = 1000,
        .max_ttl_ms = 60000,
        .k_noise = 0,
        .abs_eps_floor = 0,
        .range_eps_floor = 0,
        .win_size = 0,
        .safe_default = 500,    /* 默认500mA */
        .writable = true,
        .reg_wr = CHG_REG_TERM_CURRENT,
        .mask_wr = 0x0F,
        .shift_wr = 0,
        .min_req_gap_ms = 100,
    },
};

/* Property Engine操作函数 */
static int charger_pe_read_reg(void *ctx, u8 reg, u8 *val)
{
    struct charger_device *chg = ctx;
    int ret;
    /* 使用mutex保护I2C访问 */
    mutex_lock(&chg->lock);
    ret = i2c_smbus_read_byte_data(chg->client, reg);
    mutex_unlock(&chg->lock);
    if (ret < 0) {
        dev_err(chg->dev, "Failed to read reg 0x%02x: %d\n", reg, ret);
        return ret;
    }
    *val = (u8)ret;
    return 0;
}
static int charger_pe_write_reg(void *ctx, u8 reg, u8 val)
{
    struct charger_device *chg = ctx;
    int ret;
    /* 使用mutex保护I2C访问 */
    mutex_lock(&chg->lock);
    ret = i2c_smbus_write_byte_data(chg->client, reg, val);
    mutex_unlock(&chg->lock);
    if (ret < 0) {
        dev_err(chg->dev, "Failed to write reg 0x%02x: %d\n", reg, ret);
        return ret;
    }
    return 0;
}
static const struct pe_ops charger_pe_ops = {
    .read_reg = charger_pe_read_reg,
    .write_reg = charger_pe_write_reg,
};

static int charger_get_property(struct power_supply *psy,
                               enum power_supply_property psp,
                               union power_supply_propval *val)
{
    struct charger_device *chg = power_supply_get_drvdata(psy);
    s32 cached_val;
    int ret;
    switch (psp) {
    case POWER_SUPPLY_PROP_STATUS:
        ret = pe_get_cached(chg->pe, CHG_PROP_STATUS, &cached_val);

        break;
    case POWER_SUPPLY_PROP_VOLTAGE_NOW:
        ret = pe_get_cached(chg->pe, CHG_PROP_VOLTAGE, &cached_val);

        break;
    //...
}

/* 系统唤醒时触发事件 */
static int charger_resume(struct device *dev)
{
    struct charger_device *chg = dev_get_drvdata(dev);
    if (chg && chg->pe) {
        pe_on_event(chg->pe);
    }
    return 0;
}
/* USB插拔事件 */
static void charger_usb_event(struct notifier_block *nb, 
                             unsigned long event, void *ptr)
{
    struct charger_device *chg = container_of(nb, struct charger_device,
                                             usb_notifier);
    if (chg && chg->pe) {
        pe_on_event(chg->pe);
    }
}

static int charger_remove(struct i2c_client *client)
{
    struct charger_device *chg = i2c_get_clientdata(client);

    if (chg->pe) {
        pe_destroy(chg->pe);
        g_charger_pe = NULL;
        chg->pe = NULL;
    }

    if (chg->psy)
        power_supply_unregister(chg->psy);

    mutex_destroy(&chg->lock);

    return 0;
}