static int __init battery_init(void) //drivers\power\mediatek\battery_common.c
ret = platform_driver_register(&battery_driver); //注册battert driver驱动
static struct platform_driver battery_driver = {
.probe = battery_probe,
.remove = battery_remove,
.shutdown = battery_shutdown,
.driver = {
.name = "battery",
.pm = &battery_pm_ops,
},
};
ret = platform_driver_register(&mt_batteryNotify_driver);
static struct platform_driver mt_batteryNotify_driver = {
.probe = mt_batteryNotify_probe,
.driver = {
.name = "mt-battery",
},
};
ret = platform_driver_register(&battery_dts_driver);
static struct platform_driver battery_dts_driver = {
.probe = battery_dts_probe,
.remove = NULL,
.shutdown = NULL,
.driver = {
.name = "battery-dts",
#ifdef CONFIG_OF
.of_match_table = mt_battery_of_match,
#endif
},
};
//mt6735.dtsi中定义如下设备信息
BATTERY {
compatible = "mediatek,battery";
};
BAT_NOTIFY {
compatible = "mediatek,bat_notify";
};
ret = platform_driver_register(&mt_batteryNotify_dts_driver);
static struct platform_driver mt_batteryNotify_dts_driver = {
.probe = mt_batteryNotify_dts_probe,
.driver = {
.name = "mt-dts-battery",
#ifdef CONFIG_OF
.of_match_table = mt_bat_notify_of_match,
#endif
},
};
ret = register_pm_notifier(&battery_pm_notifier_block); //注册pm通知项，系统休眠唤醒时会回调
static struct notifier_block battery_pm_notifier_block = {
.notifier_call = battery_pm_event,
.priority = 0,
};
static int battery_pm_event(struct notifier_block *notifier, unsigned long pm_event, void *unused)
switch(pm_event) {//根据休眠唤醒的通知类型，对模块做休眠唤醒
case PM_HIBERNATION_PREPARE: /* Going to hibernate */
case PM_RESTORE_PREPARE: /* Going to restore a saved image */
case PM_SUSPEND_PREPARE: /* Going to suspend the system */
pr_warn("[%s] pm_event %lu\n", __func__, pm_event);
battery_timer_pause();
return NOTIFY_DONE;
case PM_POST_HIBERNATION: /* Hibernation finished */
case PM_POST_SUSPEND: /* Suspend finished */
case PM_POST_RESTORE: /* Restore failed */
pr_warn("[%s] pm_event %lu\n", __func__, pm_event);
battery_timer_resume();
static int battery_dts_probe(struct platform_device *dev) //mt6735.dtsi中定义了mediatek,battery和mediatek,bat_notify，所以回调对应的probe函数
battery_device.dev.of_node = dev->dev.of_node; //初始化设备节点
ret = platform_device_register(&battery_device); //注册battery device设备，这里会触发battery的probe被调用
static int mt_batteryNotify_dts_probe(struct platform_device *dev)
MT_batteryNotify_device.dev.of_node = dev->dev.of_node; //初始化设备节点
ret = platform_device_register(&MT_batteryNotify_device); //注册batteryNotify设备，会触发mt-battery的probe被调用
static int mt_batteryNotify_probe(struct platform_device *dev)
//创建设备文件
ret_device_file = device_create_file(&(dev->dev), &dev_attr_BatteryNotify);
ret_device_file = device_create_file(&(dev->dev), &dev_attr_BN_TestMode);
//proc文件系统创建mtk_battery_cmd目录
battery_dir = proc_mkdir("mtk_battery_cmd", NULL);
//mtk_battery_cmd目录下创建相关设备文件信息
proc_create("battery_cmd", S_IRUGO | S_IWUSR, battery_dir, &battery_cmd_proc_fops);
proc_create("current_cmd", S_IRUGO | S_IWUSR, battery_dir, ¤t_cmd_proc_fops);
proc_create("discharging_cmd", S_IRUGO | S_IWUSR, battery_dir, &discharging_cmd_proc_fops);
static const struct file_operations discharging_cmd_proc_fops = {
.open = proc_utilization_open,
.read = seq_read,
.write = discharging_cmd_write,
};
static const struct file_operations current_cmd_proc_fops = {
.open = proc_utilization_open_cur_stop,
.read = seq_read,
.write = current_cmd_write,
};
static const struct file_operations battery_cmd_proc_fops = {
.open = proc_utilization_open,
.read = seq_read,
.write = battery_cmd_write,
};
static int battery_probe(struct platform_device *dev)
//创建字符设备MT_pmic_adc_cali
ret = alloc_chrdev_region(&adc_cali_devno, 0, 1, ADC_CALI_DEVNAME);
//字符设备初始化
adc_cali_cdev = cdev_alloc();
adc_cali_cdev->owner = THIS_MODULE;
adc_cali_cdev->ops = &adc_cali_fops;//字符设备操作集
//创建类、设备文件
adc_cali_major = MAJOR(adc_cali_devno);
adc_cali_class = class_create(THIS_MODULE, ADC_CALI_DEVNAME);
class_dev = (struct class_device *)device_create(adc_cali_class,NULL,adc_cali_devno, NULL, ADC_CALI_DEVNAME);
get_charging_control();//获取电池相关的操作接口
battery_charging_control = chr_control_interface;//这里管理fan5405.c
battery_charging_control(CHARGING_CMD_GET_PLATFORM_BOOT_MODE, &g_platform_boot_mode);//获取平台启动模式
static kal_uint32 charging_get_platfrom_boot_mode(void *data)//drivers\power\mediatek\power\mt6735\fan5405.c
*(kal_uint32*)(data) = get_boot_mode();
init_boot_common(__LINE__);
return g_boot_mode;
wake_lock_init(&battery_fg_lock, WAKE_LOCK_SUSPEND, "battery fg wakelock");//初始化wake_lock锁
wake_lock_init(&battery_suspend_lock, WAKE_LOCK_SUSPEND, "battery suspend wakelock");
ret = power_supply_register(&(dev->dev), &ac_main.psy);//注册ac_main的power_supply
ret = power_supply_register(&(dev->dev), &usb_main.psy);//注册usb_main的power_supply
ret = power_supply_register(&(dev->dev), &wireless_main.psy);//注册battery_main的power_supply
//创建各种设备文件接口
.......
//初始化PMU_ChargerStruct结构
BMT_status.bat_exist = KAL_TRUE; //电池状态，是否存在
BMT_status.charger_exist = KAL_FALSE; //充电状态，是否在冲
BMT_status.bat_vol = 0; //电池平均电压
BMT_status.ICharging = 0; //充电电流
BMT_status.temperature = 0; //电池温度
BMT_status.charger_vol = 0; //charger电压
BMT_status.total_charging_time = 0; //总的充电时间
BMT_status.PRE_charging_time = 0; //pre cc充电时间
BMT_status.CC_charging_time = 0; //cc充电时间
BMT_status.TOPOFF_charging_time = 0; //top off充电时间
BMT_status.POSTFULL_charging_time = 0; //post full充电时间
BMT_status.SOC = 0; //底层的电量
BMT_status.UI_SOC = 0; //上层ui的电量
BMT_status.bat_charging_state = CHR_PRE; //判断充电状态
BMT_status.bat_in_recharging_state = KAL_FALSE; //电池是否在回充
BMT_status.bat_full = KAL_FALSE; //电池是否充满
BMT_status.nPercent_ZCV = 0;
BMT_status.nPrecent_UI_SOC_check_point = battery_meter_get_battery_nPercent_UI_SOC();
//battery线程定时器初始化，10s轮训一次
battery_kthread_hrtimer_init();
ktime = ktime_set(1, 0); /* 3s, 10* 1000 ms */
hrtimer_init(&battery_kthread_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
battery_kthread_timer.function = battery_kthread_hrtimer_func;
hrtimer_start(&battery_kthread_timer, ktime, HRTIMER_MODE_REL);
enum hrtimer_restart battery_kthread_hrtimer_func(struct hrtimer *timer)
bat_thread_wakeup();
bat_thread_timeout = KAL_TRUE;
bat_meter_timeout = KAL_TRUE;
suspend_time = 0;
_g_bat_sleep_total_time = 0;
wake_up(&bat_thread_wq);//唤醒等待队列
static DECLARE_WAIT_QUEUE_HEAD(bat_thread_wq);//初始化bat_thread_wq等待队列
//创建内核线程
kthread_run(bat_thread_kthread, NULL, "bat_thread_kthread");
int bat_thread_kthread(void *x)
charger_hv_detect_sw_workaround_init();
//创建一个定时器
ktime = ktime_set(0, BAT_MS_TO_NS(2000));
hrtimer_init(&charger_hv_detect_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
charger_hv_detect_timer.function = charger_hv_detect_sw_workaround;
hrtimer_start(&charger_hv_detect_timer, ktime, HRTIMER_MODE_REL);
enum hrtimer_restart charger_hv_detect_sw_workaround(struct hrtimer *timer)
charger_hv_detect_flag = KAL_TRUE;
wake_up_interruptible(&charger_hv_detect_waiter);//唤醒等待队列
static DECLARE_WAIT_QUEUE_HEAD(charger_hv_detect_waiter);
//创建电池hv检测线程
charger_hv_detect_thread =kthread_run(charger_hv_detect_sw_thread_handler, 0,"mtk charger_hv_detect_sw_workaround");
check_battery_exist(); //检测电池是否存在
battery_charging_control(CHARGING_CMD_GET_BATTERY_STATUS, &battery_status);//获取电池状态
init_proc_log();//初始化proc文件系统log信息文件
g_bat_init_flag = KAL_TRUE;
***************************************************************************
int charger_hv_detect_sw_thread_handler(void *unused) //hv检测线程分析
kal_uint32 hv_voltage = V_CHARGER_MAX*1000;
do{
if (BMT_status.charger_exist == KAL_TRUE){//是否在充电
ktime = ktime_set(0, BAT_MS_TO_NS(200)); //200ms
}
else{
ktime = ktime_set(0, BAT_MS_TO_NS(1000));//1s
}
if (chargin_hw_init_done)
battery_charging_control(CHARGING_CMD_SET_HV_THRESHOLD, &hv_voltage);//此处调用fan5405.c对应接口设备hv_threshold
//加入charger_hv_detect_waiter等待队列，只到charger_hv_detect_flag == KAL_TRUE
wait_event_interruptible(charger_hv_detect_waiter,(charger_hv_detect_flag == KAL_TRUE));
if(BMT_status.charger_exist == KAL_TRUE){
if(cnt>=5){
hv_sw_mode();
cnt=0;
}else{
cnt++;
}
charger_plug_out_sw_mode();
}else{
hv_sw_mode();
}
charger_hv_detect_flag = KAL_FALSE; //设置charger_hv_detect_flag为false
hrtimer_start(&charger_hv_detect_timer, ktime, HRTIMER_MODE_REL);//重启启动定时器
} while (!kthread_should_stop());
************************************
int bat_thread_kthread(void *x)//battery线程分析
void BAT_thread(void)
mt_battery_charger_detect_check();//检测充电状态
if (upmu_is_chr_det() == KAL_TRUE) {
wake_lock(&battery_suspend_lock);//充电上锁
BMT_status.charger_exist = KAL_TRUE;//正在充电
if (BMT_status.charger_type == CHARGER_UNKNOWN) {//如果充电类型不明确
mt_charger_type_detection();//检测充电类型
//获取充电类型
battery_charging_control(CHARGING_CMD_GET_CHARGER_TYPE, &CHR_Type_num);
BMT_status.charger_type = CHR_Type_num;
if ((BMT_status.charger_type == STANDARD_HOST)|| (BMT_status.charger_type == CHARGING_HOST)) {
mt_usb_connect();//如果是USB，做一些设置
}
}
}else {
wake_unlock(&battery_suspend_lock);//解锁
//参数初始化
BMT_status.charger_exist = KAL_FALSE;
BMT_status.charger_type = CHARGER_UNKNOWN;
BMT_status.bat_full = KAL_FALSE;
BMT_status.bat_in_recharging_state = KAL_FALSE;
BMT_status.bat_charging_state = CHR_PRE;
BMT_status.total_charging_time = 0;
BMT_status.PRE_charging_time = 0;
BMT_status.CC_charging_time = 0;
BMT_status.TOPOFF_charging_time = 0;
BMT_status.POSTFULL_charging_time = 0;
mt_usb_disconnect();//断开usb配置
}
//获取电池相关数据
mt_battery_GetBatteryData();
bat_vol = battery_meter_get_battery_voltage(KAL_TRUE);//获取电池电压
Vsense = battery_meter_get_VSense();
if( upmu_is_chr_det() == KAL_TRUE ) {//是否在充电
ICharging = battery_meter_get_charging_current();//获取充电电流
} else {
ICharging = 0;
}
charger_vol = battery_meter_get_charger_voltage();
temperature = battery_meter_get_battery_temperature();
temperatureV = battery_meter_get_tempV();
temperatureR = battery_meter_get_tempR(temperatureV);
SOC = battery_meter_get_battery_percentage();//获取电池电量
#if defined(SOC_BY_HW_FG)//通过硬件ADC获取电量
if (g_auxadc_solution == 1) {
return auxadc_algo_run();
} else {
fgauge_algo_run();
#if !defined(CUST_CAPACITY_OCV2CV_TRANSFORM)
return gFG_capacity_by_c; /* hw fg, //return gfg_percent_check_point; // voltage mode */
#else
/* We keep gFG_capacity_by_c as capacity before compensation */
/* Compensated capacity is returned for UI SOC tracking */
return 100 - battery_meter_trans_battery_percentage(100 - gFG_capacity_by_c);
#endif
}
#endif
ZCV = battery_meter_get_battery_zcv();
BMT_status.ICharging =mt_battery_average_method(BATTERY_AVG_CURRENT, &batteryCurrentBuffer[0], ICharging, &icharging_sum,batteryIndex);
if (BMT_status.charger_exist == KAL_TRUE) {
check_battery_exist();
}
mt_battery_thermal_check();//电池温度检测及开机mode
mt_battery_notify_check();//检测电池电压、电流等
if (BMT_status.charger_exist == KAL_TRUE) {
mt_battery_CheckBatteryStatus();//充电异常检测
mt_battery_charging_algorithm(); //切换充电模式 pre cc ->cc->dc
}
static void mt_battery_update_status(void) //上报电池数据
usb_update(&usb_main); //更新usb状态
ac_update(&ac_main); //更新ac状态
wireless_update(&wireless_main); //无线充电不支持
battery_update(&battery_main); //上报电池数据
bat_data->BAT_TECHNOLOGY = POWER_SUPPLY_TECHNOLOGY_LION;
bat_data->BAT_HEALTH = POWER_SUPPLY_HEALTH_GOOD;
bat_data->BAT_batt_vol = BMT_status.bat_vol;
bat_data->BAT_batt_temp = BMT_status.temperature * 10;
bat_data->BAT_PRESENT = BMT_status.bat_exist;
if ((BMT_status.charger_exist == KAL_TRUE) && (BMT_status.bat_charging_state != CHR_ERROR)) {
if (BMT_status.bat_exist) { /* charging */ //电池在，并且在充电
if (BMT_status.bat_vol <= V_0PERCENT_TRACKING) { //电池电压小于3.45V
resetBatteryMeter = mt_battery_0Percent_tracking_check();
/**if (BMT_status.UI_SOC <= 0) {
BMT_status.UI_SOC = 0; //soc小于0，则显示0
#ifndef DISABLE_DLPT_FEATURE
if (BMT_status.bat_vol <= SYSTEM_OFF_VOLTAGE) //电压小于关机电压
{
reboot_cnt++;
if(reboot_cnt>=2)
{
battery_log(BAT_LOG_CRTI, "0Percent, shutdown ,VBAT < %d UI_SOC=%d reboot_cnt:%d \r\n", SYSTEM_OFF_VOLTAGE,BMT_status.UI_SOC,reboot_cnt);
kernel_restart("battery 0% reboot system");//重启内核
}
}
#endif // #ifndef DISABLE_DLPT_FEATURE
} else {
//电池电压大于关机电压，soc大于1,soc递减
if (BMT_status.bat_vol > SYSTEM_OFF_VOLTAGE && BMT_status.UI_SOC > 1) {
BMT_status.UI_SOC--;
} else if (BMT_status.bat_vol <= SYSTEM_OFF_VOLTAGE) {
BMT_status.UI_SOC--;
}
reboot_cnt=0;
}**/
} else {//电池电压大于3.45V
resetBatteryMeter = mt_battery_100Percent_tracking_check();
//如果电池充满了，则显示100%；如果充满了，但是soc小于100，则每个10s，soc加1；
//如果没充满，但是UI_SOC大于99，则显示99%，
}
bat_data->BAT_STATUS = POWER_SUPPLY_STATUS_CHARGING; //正在充电
} else { /* No Battery, Only Charger */ 无电池
bat_data->BAT_STATUS = POWER_SUPPLY_STATUS_UNKNOWN; //电源类型未知
BMT_status.UI_SOC = 0; //显示0%
}
} else { /* Only Battery *///没充电，电池供电
bat_data->BAT_STATUS = POWER_SUPPLY_STATUS_NOT_CHARGING;
if (BMT_status.bat_vol <= V_0PERCENT_TRACKING)//电压小于3.45V
//UI_SOC小于0，则显示0，电池电压小于关机电压，则重启；如果UI_SOC大于0，则UI_SOC递减
resetBatteryMeter = mt_battery_0Percent_tracking_check();
else
resetBatteryMeter = mt_battery_nPercent_tracking_check();
}
//更新电池相关参数
mt_battery_update_EM(bat_data);
bat_data->BAT_CAPACITY = BMT_status.UI_SOC;
bat_data->BAT_TemperatureR = BMT_status.temperatureR; /* API */
bat_data->BAT_TempBattVoltage = BMT_status.temperatureV; /* API */
bat_data->BAT_InstatVolt = BMT_status.bat_vol; /* VBAT */
bat_data->BAT_BatteryAverageCurrent = BMT_status.ICharging;
bat_data->BAT_BatterySenseVoltage = BMT_status.bat_vol;
bat_data->BAT_ISenseVoltage = BMT_status.Vsense; /* API */
bat_data->BAT_ChargerVoltage = BMT_status.charger_vol;
/* Dual battery */
bat_data->status_smb = g_status_smb;
bat_data->capacity_smb = g_capacity_smb;
bat_data->present_smb = g_present_smb;
//如果在充电，并且UI_SOC等于100，则设置充满标志
if ((BMT_status.UI_SOC == 100) && (BMT_status.charger_exist == KAL_TRUE))
bat_data->BAT_STATUS = POWER_SUPPLY_STATUS_FULL;
power_supply_changed(bat_psy);//更新状态，发送uevent(KOBJ_CHANGE)，告诉batteryService
mt_kpoc_power_off_check(); //关机充电
扫一扫
7846
评论
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
查看更多评论
添加红包
