mt6750 battery_common.c阅读笔记1

static int battery_probe(struct platform_device *dev)
{
    struct class_device *class_dev = NULL;
    int ret = 0;

    battery_log(BAT_LOG_CRTI, "******** battery driver probe!! ********\n");

    /* Integrate with NVRAM */
    ret = alloc_chrdev_region(&adc_cali_devno, 0, 1, ADC_CALI_DEVNAME);
    if (ret)
        battery_log(BAT_LOG_CRTI, "Error: Can't Get Major number for adc_cali\n");
    adc_cali_cdev = cdev_alloc();
    adc_cali_cdev->owner = THIS_MODULE;
    adc_cali_cdev->ops = &adc_cali_fops;
    ret = cdev_add(adc_cali_cdev, adc_cali_devno, 1);
    if (ret)
        battery_log(BAT_LOG_CRTI, "adc_cali Error: cdev_add\n");
    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);
    battery_log(BAT_LOG_CRTI, "[BAT_probe] adc_cali prepare : done !!\n ");

    get_charging_control();//函数指针赋值，调用下面的charging_hw_XX里定义的函数
    batt_init_cust_data();//电池参数，dts初始化

    battery_charging_control(CHARGING_CMD_GET_PLATFORM_BOOT_MODE, &g_platform_boot_mode);//获取系统启动方式，关机充电？meta模式？还是正常的开机模式？
    battery_log(BAT_LOG_CRTI, "[BAT_probe] g_platform_boot_mode = %d\n ", g_platform_boot_mode);

//初始化锁battery_fg_lock和battery_suspend_lock
    wake_lock_init(&battery_fg_lock, WAKE_LOCK_SUSPEND, "battery fg wakelock");
    wake_lock_init(&battery_suspend_lock, WAKE_LOCK_SUSPEND, "battery suspend wakelock");
#if defined(CONFIG_MTK_PUMP_EXPRESS_SUPPORT)//是否快充的宏定义
    wake_lock_init(&TA_charger_suspend_lock, WAKE_LOCK_SUSPEND, "TA charger suspend wakelock");
#endif
//mtk快充相关的初始化代码
    mtk_pep_init();
    mtk_pep20_init();

    /* Integrate with Android Battery Service */
    ret = power_supply_register(&(dev->dev), &ac_main.psy);
    if (ret) {
        battery_log(BAT_LOG_CRTI, "[BAT_probe] power_supply_register AC Fail !!\n");
        return ret;
    }
    battery_log(BAT_LOG_CRTI, "[BAT_probe] power_supply_register AC Success !!\n");

    ret = power_supply_register(&(dev->dev), &usb_main.psy);
    if (ret) {
        battery_log(BAT_LOG_CRTI, "[BAT_probe] power_supply_register USB Fail !!\n");
        return ret;
    }
    battery_log(BAT_LOG_CRTI, "[BAT_probe] power_supply_register USB Success !!\n");

    ret = power_supply_register(&(dev->dev), &wireless_main.psy);
    if (ret) {
        battery_log(BAT_LOG_CRTI, "[BAT_probe] power_supply_register WIRELESS Fail !!\n");
        return ret;
    }
    battery_log(BAT_LOG_CRTI, "[BAT_probe] power_supply_register WIRELESS Success !!\n");

    ret = power_supply_register(&(dev->dev), &battery_main.psy);
//注册battery的powersupply
    if (ret) {
        battery_log(BAT_LOG_CRTI, "[BAT_probe] power_supply_register Battery Fail !!\n");
        return ret;
    }
    battery_log(BAT_LOG_CRTI, "[BAT_probe] power_supply_register Battery Success !!\n");

#if !defined(CONFIG_POWER_EXT)

#ifdef CONFIG_MTK_POWER_EXT_DETECT
    if (KAL_TRUE == bat_is_ext_power()) {
        battery_main.BAT_STATUS = POWER_SUPPLY_STATUS_FULL;
        battery_main.BAT_HEALTH = POWER_SUPPLY_HEALTH_GOOD;
        battery_main.BAT_PRESENT = 1;
        battery_main.BAT_TECHNOLOGY = POWER_SUPPLY_TECHNOLOGY_LION;
        battery_main.BAT_CAPACITY = 100;
        battery_main.BAT_batt_vol = 4200;
        battery_main.BAT_batt_temp = 220;

        g_bat_init_flag = KAL_TRUE;
        return 0;
    }
#endif
    /* For EM */


    /* battery_meter_initial();      //move to mt_battery_GetBatteryData() to decrease booting time */

    /* Initialization BMT Struct */
    BMT_status.bat_exist = KAL_TRUE;    /* 电池是否在位phone must have battery */
    BMT_status.charger_exist = KAL_FALSE;   /*充电器是否在位 for default, no charger */
    BMT_status.bat_vol = 0;//电池电压
    BMT_status.ICharging = 0;//进电池电流
    BMT_status.temperature = 0;//电池温度
    BMT_status.charger_vol = 0;//充电器电压
    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;
    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;// nPercent_ZCV
    BMT_status.nPrecent_UI_SOC_check_point = battery_meter_get_battery_nPercent_UI_SOC();

#if defined(CONFIG_MTK_DUAL_INPUT_CHARGER_SUPPORT)
    dual_input_init();
#endif

    /* battery kernel thread for 10s check and charger in/out event */
    /* Replace GPT timer by hrtime */
    battery_kthread_hrtimer_init();

    kthread_run(bat_thread_kthread, NULL, "bat_thread_kthread");
//创建内核线程bat_thread_kthread，线程处理函数bat_thread_kthread后面分析
    battery_log(BAT_LOG_CRTI, "[battery_probe] bat_thread_kthread Done\n");


    charger_hv_detect_sw_workaround_init();


    /*LOG System Set */
    init_proc_log();

#else
    /* keep HW alive */
    /* charger_hv_detect_sw_workaround_init(); */
#endif
    g_bat_init_flag = KAL_TRUE;

#if defined(CONFIG_MTK_DUAL_INPUT_CHARGER_SUPPORT)
    if ((g_vcdt_irq_delay_flag == KAL_TRUE) || (upmu_is_chr_det() == KAL_TRUE))
        do_chrdet_int_task();
#endif

    return 0;
}


//定时器初始化函数
void battery_kthread_hrtimer_init(void)
{
    ktime_t ktime;
#ifdef CONFIG_MTK_BQ25896_SUPPORT
/*watchdog timer before 40 secs*/
    ktime = ktime_set(BAT_TASK_PERIOD, 0);  /* 3s, 10* 1000 ms */
#else
    ktime = ktime_set(1, 0);
#endif
    hrtimer_init(&battery_kthread_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
// hrtimer_init初始化定时器工作模式。
    battery_kthread_timer.function = battery_kthread_hrtimer_func;
// 设置定时器的回调函数，定时器到时该函数将被调用 

    hrtimer_start(&battery_kthread_timer, ktime, HRTIMER_MODE_REL);
//启动定时器，超时时间为ktime
    battery_log(BAT_LOG_CRTI, "battery_kthread_hrtimer_init : done\n");
}


定时时间到处理函数
enum hrtimer_restart battery_kthread_hrtimer_func(struct hrtimer *timer)
{
    bat_thread_wakeup();

    return HRTIMER_NORESTART;
}

int bat_thread_kthread(void *x)
{
    ktime_t ktime = ktime_set(3, 0);    /* 10s, 10* 1000 ms */

#ifdef BATTERY_CDP_WORKAROUND2
    if (is_usb_rdy() == KAL_FALSE) {
        battery_log(BAT_LOG_CRTI, "CDP, block\n");
        wait_event(bat_thread_wq, (is_usb_rdy() == KAL_TRUE));
        battery_log(BAT_LOG_CRTI, "CDP, free\n");
    } else {
        battery_log(BAT_LOG_CRTI, "CDP, PASS\n");
    }
#endif
#if defined(BATTERY_SW_INIT)
        battery_charging_control(CHARGING_CMD_SW_INIT, NULL);
#endif

    /* Run on a process content */
    while (1) {
        mutex_lock(&bat_mutex);

        if (((chargin_hw_init_done == KAL_TRUE) && (battery_suspended == KAL_FALSE))
            || ((chargin_hw_init_done == KAL_TRUE) && (fg_wake_up_bat == KAL_TRUE)))
            BAT_thread();//电池数据处理线程

        mutex_unlock(&bat_mutex);

#ifdef FG_BAT_INT
        if (fg_wake_up_bat == KAL_TRUE) {
            wake_unlock(&battery_fg_lock);
            fg_wake_up_bat = KAL_FALSE;
            battery_log(BAT_LOG_CRTI, "unlock battery_fg_lock\n");
        }
#endif              /* #ifdef FG_BAT_INT */

        battery_log(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 */
#if defined(CONFIG_MTK_DUAL_INPUT_CHARGER_SUPPORT)
            if (DISO_data.chr_get_diso_state) {
                DISO_data.chr_get_diso_state = KAL_FALSE;
                battery_charging_control(CHARGING_CMD_GET_DISO_STATE, &DISO_data);
            }
#endif

            g_smartbook_update = 0;
            battery_meter_reset();
            chr_wake_up_bat = KAL_FALSE;

            battery_log(BAT_LOG_CRTI,
                    "[BATTERY] Charger plug in/out, Call battery_meter_reset. (%d)\n",
                    BMT_status.UI_SOC);
        }

    }

    return 0;
}