MTK Battery系统_mtk_battery.c

        MTK方案的电池充电过程分为预充、恒流充电（CC模式）、恒压充电（CV模式）三种模式，整个充电过程如下充电状态图所示：

        从充电状态图看出来，刚开始充电的时候，代码先判断是插USB充电还是插ac充电，电池在进入充电阶段分为快速充电、CC（恒流充电）、CV（恒压充电）。而从CC模式切换到CV模式在代码中的alps/mediatek/kernel/drivers/power/linear_charging.c和alps/mediatek/kernel/drivers/power/ switch_charging.c。

     MTK Battery系统驱动的大致流程主要是通过系统platform总线注册device和driver，然后在probe函数里面创建了一个线程，然后创建一个hrtimer定时器，定时器没10s运行一次，同时在probe函数里面会创建一些设备节点，通过这些设备节点，系统将每10s更新的数据上传给上层供上层调用显示。

1、battery硬件原理图

  首先先介绍几个电压值：

VCHG：USB正极

VCDT：充电电压检测脚

ISENSE：充电电流检测电阻的正极

BATSNS：充电电流检测电阻的负极

BAT：电池正极引脚

BAT_ON：电池NTC（热敏电阻）引脚 

      通过三极管可以开启，关闭充电功能，开启充电的时候调节三极管的基级电流可以控制流过三极管CE端的电流从而实现充电电流大小的设置。

     Rsense采样电阻:对于软件来说可以测量充电电流的大小：电流计算方法：（ISENSE – VBAT）/Rsense。对于PMU来说通过Rsense可以实现电流控制。比如要实现1A的充电电流，Rsense为0.2欧。PMU实现该电流的方法就是设法一直保证Rsense两端的电压是0.2V。

BAT_ON在充电中的作用：

1，检测电池是否存在。电压必须小于1.062V，否则认为电池不存在不能充电，硬件行为，软件无法关闭此功能

2，高温检测，电池电压必须大于0.2V，否则认为电池温度过高不能充电，硬件行为，软件可以关闭此功能

3，软件检测电池温度。

2、Battery架构简析

3、MTK电池驱动分析

146 typedef struct
147 {
148         kal_bool                        bat_exist;  // 判断电池是否存在
149         kal_bool                        bat_full;  //判断电池是否充满
150         INT32                   bat_charging_state; //判断充电状态
151         UINT32                  bat_vol; //电池平均电压
152         kal_bool                        bat_in_recharging_state; //电池是否在回充
153         kal_uint32              Vsense; // 电池瞬间电压
154         kal_bool                        charger_exist; // Charger是否存在Charger电压
155         UINT32                  charger_vol;  // Charger电压
156         INT32                   charger_protect_status; //充电保护状态，过流或者过压保护状态
157         INT32                   ICharging; // 充电电流
158         INT32                   IBattery;
159         INT32                   temperature; // 电池温度
160         INT32                   temperatureR;
161         INT32                   temperatureV;
162         UINT32                  total_charging_time; //总的充电时间
163         UINT32                  PRE_charging_time; // Pre cc充电时间
164         UINT32                  CC_charging_time; //cc充电时间
165         UINT32                  TOPOFF_charging_time; //TOPOFF充电时间
166         UINT32                  POSTFULL_charging_time; //Postfull充电时间
167         UINT32                  charger_type; //充电器类型
168         INT32                   SOC; //底层的电量
169         INT32                   UI_SOC; // 上层的电量
170         UINT32                  nPercent_ZCV; 
171         UINT32                  nPrecent_UI_SOC_check_point; //N%同步点对应的开路电压以及UI电量
172         UINT32                  ZCV; //电池当前开路电压
173 } PMU_ChargerStruct;

   在注册完字符设备后，probe会执行get_charging_control();这个函数，这个函数在整个充电过程中起着很重要的作用，该函数就一行代码：

static void get_charging_control(void)
{
	battery_charging_control = chr_control_interface;
}
kal_int32 chr_control_interface(CHARGING_CTRL_CMD cmd, void *data)
{
        kal_int32 status;
        if(cmd < CHARGING_CMD_NUMBER)
               status = charging_func[cmd](data);
        else
                return STATUS_UNSUPPORTED;
         return status;
  }

typedef enum
{
        CHARGING_CMD_INIT,
       CHARGING_CMD_DUMP_REGISTER,
        CHARGING_CMD_ENABLE,
        CHARGING_CMD_SET_CV_VOLTAGE,
        CHARGING_CMD_GET_CURRENT,
        CHARGING_CMD_SET_CURRENT,
        CHARGING_CMD_SET_INPUT_CURRENT,
        CHARGING_CMD_GET_CHARGING_STATUS,
        CHARGING_CMD_RESET_WATCH_DOG_TIMER,
        CHARGING_CMD_SET_HV_THRESHOLD,
        CHARGING_CMD_GET_HV_STATUS,
        CHARGING_CMD_GET_BATTERY_STATUS,
        CHARGING_CMD_GET_CHARGER_DET_STATUS,
        CHARGING_CMD_GET_CHARGER_TYPE,
        CHARGING_CMD_GET_IS_PCM_TIMER_TRIGGER,
        CHARGING_CMD_SET_PLATFORM_RESET,
        CHARGING_CMD_GET_PLATFORM_BOOT_MODE,
        CHARGING_CMD_SET_POWER_OFF,
        CHARGING_CMD_NUMBER
} CHARGING_CTRL_CMD;

static kal_uint32 (*charging_func[CHARGING_CMD_NUMBER])(void *data)=
{
        charging_hw_init
       ,charging_dump_register
       ,charging_enable
       ,charging_set_cv_voltage
       ,charging_get_current
       ,charging_set_current
       ,charging_set_input_current             // not support, empty function
       ,charging_get_charging_status   // not support, empty function
       ,charging_reset_watch_dog_timer
       ,charging_set_hv_threshold
       ,charging_get_hv_status
       ,charging_get_battery_status
       ,charging_get_charger_det_status
       ,charging_get_charger_type
       ,charging_get_is_pcm_timer_trigger
       ,charging_set_platform_reset
       ,charging_get_platfrom_boot_mode
       ,charging_set_power_off
};

      当probe函数注册完了字符设备后，函数进行的随后的进行的操作是在sys下面建立设备节点，总共建立了四个设备节点，分别为ac_main、usb_main、wireless_main和battery_main，这四个节点分别为使用适配器、USB、无线充电以及使用电池供电。电池电量发生变化的时候，会通过这些节点将数据上报给上层，也就是说上层是通过这些节点来读取底层电池电量变化的数据的。
     当初始化完成后，probe函数会创建一个hrtimer定时器，定时器启动bat_thread_kthread函数，bat_thread_kthread函数中的while(1)里面包含了BAT_thread()函数，BAT_thread()就是充电的核心函数。

int bat_thread_kthread(void *x)
{
    ktime_t ktime = ktime_set(3, 0);  // 10s, 10* 1000 ms	
    
    /* Run on a process content */  
    while (1) {               
        mutex_lock(&bat_mutex);
		if((chargin_hw_init_done == KAL_TRUE) && (battery_suspended == KAL_FALSE))
	        BAT_thread();                      
        mutex_unlock(&bat_mutex);
        battery_xlog_printk(BAT_LOG_FULL, "wait event \n" );
		wait_event(bat_thread_wq, (bat_thread_timeout == KAL_TRUE));
        bat_thread_timeout = KAL_FALSE;
        hrtimer_start(&battery_kthread_timer, ktime, HRTIMER_MODE_REL);   
        ktime = ktime_set(BAT_TASK_PERIOD, 0);  // 10s, 10* 1000 ms
        if( chr_wake_up_bat == KAL_TRUE && g_smartbook_update != 1) // for charger plug in/ out
        {
              g_smartbook_update = 0;
           	battery_meter_reset();
			chr_wake_up_bat = KAL_FALSE; 
            battery_xlog_printk(BAT_LOG_CRTI, "[BATTERY] Charger plug in/out, Call battery_meter_reset. (%d)\n", BMT_status.UI_SOC);
        } 
}
return 0;
}

void BAT_thread(void)
{
    static kal_bool  battery_meter_initilized = KAL_FALSE;
    _g_bat_sleep_total_time = 0;
    if(battery_meter_initilized == KAL_FALSE)
    {
        battery_meter_initial();	//move from battery_probe() to decrease booting time
       	BMT_status.nPercent_ZCV = battery_meter_get_battery_nPercent_zcv();
        battery_meter_initilized = KAL_TRUE;
    }
    mt_battery_charger_detect_check();
    mt_battery_GetBatteryData();
    mt_battery_thermal_check();
    mt_battery_notify_check();    
    if( BMT_status.charger_exist == KAL_TRUE )
    {
        mt_battery_CheckBatteryStatus();	    
        mt_battery_charging_algorithm();
    }
    mt_battery_update_status();
}

battery_meter_initial函数为系统启动时运行的，也电池充电做一些初始化操作。MTK有AUXADC、SW_FG、HW_FG三种不同的电池算法方案，这三种方案分别初始化，因为82平台采用的SW_FG，所以接下去先主要分析SW_FG的流程。而SW_FG中主要是利用线性插值算法来重构zcv表格，利用积分算法求电池的当前电量。

      先来看看系统是如何利用线性插值的方法来求电池的温度，重构zcv表格，在table_init函数中：

void table_init(void)
{
    ..........
    int temperature = force_get_tbat(); //求电池的温度
 
    // Re-constructure r-table profile according to current temperature
    profile_p_r_table = fgauge_get_profile_r_table(TEMPERATURE_T);
    if (profile_p_r_table == NULL)
    {
        bm_print(BM_LOG_CRTI, "[FGADC] fgauge_get_profile_r_table : create table fail !\r\n");
    }
    fgauge_construct_r_table_profile(temperature, profile_p_r_table);
 
    // Re-constructure battery profile according to current temperature
    profile_p = fgauge_get_profile(TEMPERATURE_T);
    if (profile_p == NULL)
    {
        bm_print(BM_LOG_CRTI, "[FGADC] fgauge_get_profile : create table fail !\r\n");
    }
    fgauge_construct_battery_profile(temperature, profile_p);
}

int force_get_tbat(void)
{
……………
bat_temperature_volt = 2; 
//求的NTC电阻的电压，也就是原理图中的BAT_ON
    ret = battery_meter_ctrl(BATTERY_METER_CMD_GET_ADC_V_BAT_TEMP, &bat_temperature_volt);
    if(bat_temperature_volt != 0)
    {   
……………
        bat_temperature_val = BattVoltToTemp(bat_temperature_volt);        
    }
    return bat_temperature_val;    
#endif    
}

       NTC电阻就是通过与电阻的串联跟并联并且通过电压值来得到的。计算出系统当前NTC电阻的电阻值后，然后就调用BattThermistorConverTemp函数进行查表，对比出当前系统的温度。而BattThermistorConverTemp函数是通过alps/mediatek/custom/mt6582/kernel/battery/battery/cust_battery_meter_table.h中的Batt_Temperature_Table结构体，然后根据电阻值落在哪个区间，根据线性插值的方法求出当前电池的温度。     然后在回到table_init函数，MTK的zcv电池参数表格会预先测得的在-100 25 50 摄氏度开路电量跟放电深度之间的关系。结合真实的温度值，系统会自己构建一张当前温度值的ZCV电池曲线表格。

  // Re-constructure r-table profile according to current temperature
    profile_p_r_table = fgauge_get_profile_r_table(TEMPERATURE_T); //返回NTC电阻跟电压表格
    if (profile_p_r_table == NULL)
    {
        bm_print(BM_LOG_CRTI, "[FGADC] fgauge_get_profile_r_table : create table fail !\r\n");
}
//动态构建一个NTC电阻跟电压关系的表格
fgauge_construct_r_table_profile(temperature, profile_p_r_table);
 
R_PROFILE_STRUC_P fgauge_get_profile_r_table(kal_uint32 temperature)
{
    switch (temperature)
    {
        case TEMPERATURE_T0:
            return &r_profile_t0[g_fg_battery_id][0];
            break;
        case TEMPERATURE_T1:
            return &r_profile_t1[g_fg_battery_id][0];
            break;
        case TEMPERATURE_T2:
            return &r_profile_t2[g_fg_battery_id][0];
            break;
        case TEMPERATURE_T3:
            return &r_profile_t3[g_fg_battery_id][0];
            break;
        case TEMPERATURE_T:
            return &r_profile_temperature[0];
            break;
        default:
            return NULL;
            break;
    }
}

for (i = 0; i < saddles; i++) // 构建表格中的电压值
    {
        if( ((high_profile_p + i)->voltage) > ((low_profile_p + i)->voltage) )
        {
            temp_v_1 = (high_profile_p + i)->voltage;
            temp_v_2 = (low_profile_p + i)->voltage;    
            (temp_profile_p + i)->voltage = temp_v_2 + //采用线性平均法求电压
            (
                (
                    (temperature - low_temperature) * 
                    (temp_v_1 - temp_v_2)
                ) / 
                (high_temperature - low_temperature)                
            );
        }
        else
        {
            temp_v_1 = (low_profile_p + i)->voltage;
            temp_v_2 = (high_profile_p + i)->voltage;
            (temp_profile_p + i)->voltage = temp_v_2 +
            (
                (
                    (high_temperature - temperature) * 
                    (temp_v_1 - temp_v_2)
                ) / 
                (high_temperature - low_temperature)                
            );
        }
    }
    /* Interpolation for R_BAT */
    for (i = 0; i < saddles; i++) // 构建表格中的NTC电阻值
    {
        if( ((high_profile_p + i)->resistance) > ((low_profile_p + i)->resistance) )
        {
            temp_r_1 = (high_profile_p + i)->resistance;
            temp_r_2 = (low_profile_p + i)->resistance;    
            (temp_profile_p + i)->resistance = temp_r_2 + //采用线性平均法求电阻
            (
                (
                    (temperature - low_temperature) * 
                    (temp_r_1 - temp_r_2)
                ) / 
                (high_temperature - low_temperature)                
            );
        }
        else
        {
            temp_r_1 = (low_profile_p + i)->resistance;
            temp_r_2 = (high_profile_p + i)->resistance;
            (temp_profile_p + i)->resistance = temp_r_2 +
            (
                (
                    (high_temperature - temperature) * 
                    (temp_r_1 - temp_r_2)
                ) / 
                (high_temperature - low_temperature)                
            );
        }
    }

     table_init后面利用同样的原理，动态生成了一个开路电压与放电深度关系的结构体，这里就不介绍了。

         MTK系统是通过battery_meter_get_battery_percentage函数来读取当前电池的电量的，然后在通过设备结点，通过给上层调用。battery_meter_get_battery_percentage函数主要就是调用oam_run函数来实现电流的库伦算法。积分法是利用电流计算公式 I = Q/t来求的，它的优点时适用于各种电池，但缺点是初始电量无法获取。

      而整个积分过程可参考下图：

void oam_run(void)
{
    ……
	//now_time = rtc_read_hw_time();
	getrawmonotonic(&now_time); //获取系统当前时间
	delta_time = now_time.tv_sec - last_oam_run_time.tv_sec;
	
	last_oam_run_time = now_time;
 
    // Reconstruct table if temp changed;
    fgauge_construct_table_by_temp(); // 当电压表发生改变了的时候，重构电压表
		
    vol_bat = 15; //set avg times
    ret = battery_meter_ctrl(BATTERY_METER_CMD_GET_ADC_V_BAT_SENSE, &vol_bat); //得到闭路电压
 
    oam_i_1 = (((oam_v_ocv_1-vol_bat)*1000)*10) / oam_r_1;    //0.1mA 
    oam_i_2 = (((oam_v_ocv_2-vol_bat)*1000)*10) / oam_r_2;    //0.1mA 
 
    oam_car_1 = (oam_i_1*delta_time/3600) + oam_car_1; //0.1mAh 
    oam_car_2 = (oam_i_2*delta_time/3600) + oam_car_2; //0.1mAh
 
    oam_d_1 = oam_d0 + (oam_car_1*100/10)/gFG_BATT_CAPACITY_aging; //gFG_BATT_CAPACITY_aging is Q_MAX
    if(oam_d_1 < 0)   oam_d_1 = 0;
    if(oam_d_1 > 100) oam_d_1 = 100;
    
    oam_d_2 = oam_d0 + (oam_car_2*100/10)/gFG_BATT_CAPACITY_aging;
    if(oam_d_2 < 0)   oam_d_2 = 0;
    if(oam_d_2 > 100) oam_d_2 = 100;
    
    oam_v_ocv_1 = vol_bat + mtk_imp_tracking(vol_bat, oam_i_2, 5);
    
    oam_d_3 = fgauge_read_d_by_v(oam_v_ocv_1);        
    if(oam_d_3 < 0)   oam_d_3 = 0;
    if(oam_d_3 > 100) oam_d_3 = 100;
 
    oam_r_1 = fgauge_read_r_bat_by_v(oam_v_ocv_1);
 
    oam_v_ocv_2 = fgauge_read_v_by_d(oam_d_2);
    oam_r_2 = fgauge_read_r_bat_by_v(oam_v_ocv_2); 

        oam_run函数中算法的大致思路为：系统当前的电量通过最终的开路电压oam_v_ocv_1查ZCV表得到当前的电量值，而最终开路电压需要通过闭路电压v_bat和闭路电流oam_i_2 去回溯电池内阻，逐次逼近，而oam_i_2 通过另一种方式即电量积分更新的电压oam_v_ocv_2来得到。

      下面看看具体代码的实现。

    vol_bat = 15; //set avg times
    ret = battery_meter_ctrl(BATTERY_METER_CMD_GET_ADC_V_BAT_SENSE, &vol_bat);

    oam_i_1 = (((oam_v_ocv_1-vol_bat)*1000)*10) / oam_r_1;    //0.1mA
    oam_i_2 = (((oam_v_ocv_2-vol_bat)*1000)*10) / oam_r_2;    //0.1mA
 
    oam_car_1 = (oam_i_1*delta_time/3600) + oam_car_1; //0.1mAh
    oam_car_2 = (oam_i_2*delta_time/3600) + oam_car_2; //0.1mAh

 这里的关键是oam_i_2，这边的I2 有几个作用：

1、因为电流是通过上图的内阻IR drop得到的，而方式一内阻回溯逼近开路电压本质也是IR drop，如果使用oam_i_1 则没有意义，只能使用不同体系的I2.

2、方式二 电流积分求电量查表  同样依赖 oam_i_2 这个体系是累积积分不需要引用其他体系的参数

3、I2的方向作为充电还是放电的依据

       而oam_i_1只有作用3。这里还要注意的是oam_i_1和oam_i_2的单位是0.1mA。而oam_car_1和oam_car_2 是累积电量，同样对应的单位是0.1mAh，显然oam_car_2是算法的有效参数。

oam_v_ocv_1 = vol_bat + mtk_imp_tracking(vol_bat, oam_i_2, 5);

kal_int32 mtk_imp_tracking(kal_int32 ori_voltage, kal_int32 ori_current, kal_int32 recursion_time)
{
    kal_int32 ret_compensate_value = 0;
    kal_int32 temp_voltage_1 = ori_voltage;
    kal_int32 temp_voltage_2 = temp_voltage_1;
    int i = 0;
 
    for(i=0 ; i < recursion_time ; i++) 
    {
        gFG_resistance_bat = fgauge_read_r_bat_by_v(temp_voltage_2); 
        ret_compensate_value = ( (ori_current) * (gFG_resistance_bat + R_FG_VALUE)) / 1000;
        ret_compensate_value = (ret_compensate_value+(10/2)) / 10; 
        temp_voltage_2 = temp_voltage_1 + ret_compensate_value;
 
        bm_print(BM_LOG_FULL, "[mtk_imp_tracking] temp_voltage_2=%d,temp_voltage_1=%d,ret_compensate_value=%d,gFG_resistance_bat=%d\n", 
            temp_voltage_2,temp_voltage_1,ret_compensate_value,gFG_resistance_bat);
    }
    
    gFG_resistance_bat = fgauge_read_r_bat_by_v(temp_voltage_2); 
    ret_compensate_value = ( (ori_current) * (gFG_resistance_bat + R_FG_VALUE + FG_METER_RESISTANCE)) / 1000;    
    ret_compensate_value = (ret_compensate_value+(10/2)) / 10; 
 
    gFG_compensate_value = ret_compensate_value;
 
    bm_print(BM_LOG_FULL, "[mtk_imp_tracking] temp_voltage_2=%d,temp_voltage_1=%d,ret_compensate_value=%d,gFG_resistance_bat=%d\n", 
        temp_voltage_2,temp_voltage_1,ret_compensate_value,gFG_resistance_bat);    
 
    return ret_compensate_value;
}

   oam_r_1 = fgauge_read_r_bat_by_v(oam_v_ocv_1);
    oam_v_ocv_2 = fgauge_read_v_by_d(oam_d_2);
    oam_r_2 = fgauge_read_r_bat_by_v(oam_v_ocv_2);

   if(d5_count >= d5_count_time)
    {
        if(gFG_Is_Charging == KAL_FALSE)
        {
            if( oam_d_3 > oam_d_5 )
            {
                oam_d_5 = oam_d_5 + 1;
            }
            else
            {                
                if(oam_d_4 > oam_d_5)
                {
                    oam_d_5 = oam_d_5 + 1;
                }
            }
        }
        else
        {            
            if( oam_d_5 > oam_d_3 )
            {
                oam_d_5 = oam_d_5 - 1;
            }
            else
            {                
                if(oam_d_4 < oam_d_5)
                {
                    oam_d_5 = oam_d_5 - 1;
                }
            }
        }
        d5_count = 0;
        oam_d_3_pre = oam_d_3;
        oam_d_4_pre = oam_d_4;
    }
    else
    {
        d5_count = d5_count + 10;
    }