mt6737电池状态监测

最新推荐文章于 2023-10-20 00:03:59 发布
最新推荐文章于 2023-10-20 00:03:59 发布
阅读量964 收藏 4
点赞数
分类专栏： MTK驱动

　这里分析下mt6735平台下的电池驱动，使用的bq24296芯片(开关模式的充电方式)。

kernel-3.18/drivers/power/mediatek/battery_common.c

[cpp]  view plain  copy
  1. static int battery_probe(struct platform_device *dev)  
  2. {  
  3.     struct class_device *class_dev = NULL;  
  4.     int ret = 0;  
  5.   
  6.     battery_log(BAT_LOG_CRTI, "******** battery driver probe!! ********\n");  
  7.   
  8.     /* Integrate with NVRAM */  
  9.     ret = alloc_chrdev_region(&adc_cali_devno, 0, 1, ADC_CALI_DEVNAME);  
  10.     if (ret)  
  11.         battery_log(BAT_LOG_CRTI, "Error: Can't Get Major number for adc_cali\n");  
  12.     adc_cali_cdev = cdev_alloc();  
  13.     adc_cali_cdev->owner = THIS_MODULE;  
  14.     adc_cali_cdev->ops = &adc_cali_fops;  
  15.     ret = cdev_add(adc_cali_cdev, adc_cali_devno, 1);  
  16.     if (ret)  
  17.         battery_log(BAT_LOG_CRTI, "adc_cali Error: cdev_add\n");  
  18.     adc_cali_major = MAJOR(adc_cali_devno);  
  19.     adc_cali_class = class_create(THIS_MODULE, ADC_CALI_DEVNAME);  
  20.     class_dev = (struct class_device *)device_create(adc_cali_class,  
  21.                              NULL,  
  22.                              adc_cali_devno, NULL, ADC_CALI_DEVNAME);  
  23.     battery_log(BAT_LOG_CRTI, "[BAT_probe] adc_cali prepare : done !!\n ");  
  24.   
  25.     get_charging_control();  
  26.   
  27.     batt_init_cust_data();  
  28.   
  29.     battery_charging_control(CHARGING_CMD_GET_PLATFORM_BOOT_MODE, &g_platform_boot_mode);  
  30.     battery_log(BAT_LOG_CRTI, "[BAT_probe] g_platform_boot_mode = %d\n ", g_platform_boot_mode);  
  31.   
  32.     wake_lock_init(&battery_fg_lock, WAKE_LOCK_SUSPEND, "battery fg wakelock");  
  33.   
  34.     wake_lock_init(&battery_suspend_lock, WAKE_LOCK_SUSPEND, "battery suspend wakelock");  
  35. #if defined(CONFIG_MTK_PUMP_EXPRESS_SUPPORT)  
  36.     wake_lock_init(&TA_charger_suspend_lock, WAKE_LOCK_SUSPEND, "TA charger suspend wakelock");  
  37. #endif  
  38.   
  39.     mtk_pep_init();  
  40.     mtk_pep20_init();  
  41.   
  42.     /* Integrate with Android Battery Service */  
  43.     ret = power_supply_register(&(dev->dev), &ac_main.psy);  
  44.     if (ret) {  
  45.         battery_log(BAT_LOG_CRTI, "[BAT_probe] power_supply_register AC Fail !!\n");  
  46.         return ret;  
  47.     }  
  48.     battery_log(BAT_LOG_CRTI, "[BAT_probe] power_supply_register AC Success !!\n");  
  49.   
  50.     ret = power_supply_register(&(dev->dev), &usb_main.psy);  
  51.     if (ret) {  
  52.         battery_log(BAT_LOG_CRTI, "[BAT_probe] power_supply_register USB Fail !!\n");  
  53.         return ret;  
  54.     }  
  55.     battery_log(BAT_LOG_CRTI, "[BAT_probe] power_supply_register USB Success !!\n");  
  56.   
  57.     ret = power_supply_register(&(dev->dev), &wireless_main.psy);  
  58.     if (ret) {  
  59.         battery_log(BAT_LOG_CRTI, "[BAT_probe] power_supply_register WIRELESS Fail !!\n");  
  60.         return ret;  
  61.     }  
  62.     battery_log(BAT_LOG_CRTI, "[BAT_probe] power_supply_register WIRELESS Success !!\n");  
  63.   
  64.     ret = power_supply_register(&(dev->dev), &battery_main.psy);  
  65.     if (ret) {  
  66.         battery_log(BAT_LOG_CRTI, "[BAT_probe] power_supply_register Battery Fail !!\n");  
  67.         return ret;  
  68.     }  
  69.     battery_log(BAT_LOG_CRTI, "[BAT_probe] power_supply_register Battery Success !!\n");  
  70.   
  71. #if !defined(CONFIG_POWER_EXT)  
  72.   
  73. #ifdef CONFIG_MTK_POWER_EXT_DETECT  
  74.     if (KAL_TRUE == bat_is_ext_power()) {  
  75.         battery_main.BAT_STATUS = POWER_SUPPLY_STATUS_FULL;  
  76.         battery_main.BAT_HEALTH = POWER_SUPPLY_HEALTH_GOOD;  
  77.         battery_main.BAT_PRESENT = 1;  
  78.         battery_main.BAT_TECHNOLOGY = POWER_SUPPLY_TECHNOLOGY_LION;  
  79.         battery_main.BAT_CAPACITY = 100;  
  80.         battery_main.BAT_batt_vol = 4200;  
  81.         battery_main.BAT_batt_temp = 220;  
  82.   
  83.         g_bat_init_flag = KAL_TRUE;  
  84.         return 0;  
  85.     }  
  86. #endif  
  87.     /* For EM */  
  88.     {  
  89.         int ret_device_file = 0;  
  90.   
  91.         ret_device_file = device_create_file(&(dev->dev), &dev_attr_ADC_Charger_Voltage);  
  92.   
  93.         ret_device_file = device_create_file(&(dev->dev), &dev_attr_ADC_Channel_0_Slope);  
  94.         ret_device_file = device_create_file(&(dev->dev), &dev_attr_ADC_Channel_1_Slope);  
  95.         ret_device_file = device_create_file(&(dev->dev), &dev_attr_ADC_Channel_2_Slope);  
  96.         ret_device_file = device_create_file(&(dev->dev), &dev_attr_ADC_Channel_3_Slope);  
  97.         ret_device_file = device_create_file(&(dev->dev), &dev_attr_ADC_Channel_4_Slope);  
  98.         ret_device_file = device_create_file(&(dev->dev), &dev_attr_ADC_Channel_5_Slope);  
  99.         ret_device_file = device_create_file(&(dev->dev), &dev_attr_ADC_Channel_6_Slope);  
  100.         ret_device_file = device_create_file(&(dev->dev), &dev_attr_ADC_Channel_7_Slope);  
  101.         ret_device_file = device_create_file(&(dev->dev), &dev_attr_ADC_Channel_8_Slope);  
  102.         ret_device_file = device_create_file(&(dev->dev), &dev_attr_ADC_Channel_9_Slope);  
  103.         ret_device_file = device_create_file(&(dev->dev), &dev_attr_ADC_Channel_10_Slope);  
  104.         ret_device_file = device_create_file(&(dev->dev), &dev_attr_ADC_Channel_11_Slope);  
  105.         ret_device_file = device_create_file(&(dev->dev), &dev_attr_ADC_Channel_12_Slope);  
  106.         ret_device_file = device_create_file(&(dev->dev), &dev_attr_ADC_Channel_13_Slope);  
  107.   
  108.         ret_device_file = device_create_file(&(dev->dev), &dev_attr_ADC_Channel_0_Offset);  
  109.         ret_device_file = device_create_file(&(dev->dev), &dev_attr_ADC_Channel_1_Offset);  
  110.         ret_device_file = device_create_file(&(dev->dev), &dev_attr_ADC_Channel_2_Offset);  
  111.         ret_device_file = device_create_file(&(dev->dev), &dev_attr_ADC_Channel_3_Offset);  
  112.         ret_device_file = device_create_file(&(dev->dev), &dev_attr_ADC_Channel_4_Offset);  
  113.         ret_device_file = device_create_file(&(dev->dev), &dev_attr_ADC_Channel_5_Offset);  
  114.         ret_device_file = device_create_file(&(dev->dev), &dev_attr_ADC_Channel_6_Offset);  
  115.         ret_device_file = device_create_file(&(dev->dev), &dev_attr_ADC_Channel_7_Offset);  
  116.         ret_device_file = device_create_file(&(dev->dev), &dev_attr_ADC_Channel_8_Offset);  
  117.         ret_device_file = device_create_file(&(dev->dev), &dev_attr_ADC_Channel_9_Offset);  
  118.         ret_device_file = device_create_file(&(dev->dev), &dev_attr_ADC_Channel_10_Offset);  
  119.         ret_device_file = device_create_file(&(dev->dev), &dev_attr_ADC_Channel_11_Offset);  
  120.         ret_device_file = device_create_file(&(dev->dev), &dev_attr_ADC_Channel_12_Offset);  
  121.         ret_device_file = device_create_file(&(dev->dev), &dev_attr_ADC_Channel_13_Offset);  
  122.   
  123.         ret_device_file =device_create_file(&(dev->dev), &dev_attr_ADC_Channel_Is_Calibration);  
  124.         ret_device_file = device_create_file(&(dev->dev), &dev_attr_Power_On_Voltage);  
  125.         ret_device_file = device_create_file(&(dev->dev), &dev_attr_Power_Off_Voltage);  
  126.         ret_device_file = device_create_file(&(dev->dev), &dev_attr_Charger_TopOff_Value);  
  127.   
  128.         ret_device_file =device_create_file(&(dev->dev), &dev_attr_FG_Battery_CurrentConsumption);  
  129.         ret_device_file = device_create_file(&(dev->dev), &dev_attr_FG_SW_CoulombCounter);  
  130.         ret_device_file = device_create_file(&(dev->dev), &dev_attr_Charging_CallState);  
  131.         ret_device_file = device_create_file(&(dev->dev), &dev_attr_V_0Percent_Tracking);  
  132.   
  133.         ret_device_file = device_create_file(&(dev->dev), &dev_attr_Charger_Type);  
  134.         ret_device_file = device_create_file(&(dev->dev), &dev_attr_Pump_Express);  
  135.     }  
  136.   
  137.     /* battery_meter_initial();      //move to mt_battery_GetBatteryData() to decrease booting time */  
  138.   
  139.     /* Initialization BMT Struct */  
  140.     BMT_status.bat_exist = KAL_TRUE;    /* phone must have battery */  
  141.     BMT_status.charger_exist = KAL_FALSE;   /* for default, no charger */  
  142.     BMT_status.bat_vol = 0;  
  143.     BMT_status.ICharging = 0;  
  144.     BMT_status.temperature = 0;  
  145.     BMT_status.charger_vol = 0;  
  146.     BMT_status.total_charging_time = 0;  
  147.     BMT_status.PRE_charging_time = 0;  
  148.     BMT_status.CC_charging_time = 0;  
  149.     BMT_status.TOPOFF_charging_time = 0;  
  150.     BMT_status.POSTFULL_charging_time = 0;  
  151.     BMT_status.SOC = 0;  
  152.     BMT_status.UI_SOC = 0;  
  153.   
  154.     BMT_status.bat_charging_state = CHR_PRE;  
  155.     BMT_status.bat_in_recharging_state = KAL_FALSE;  
  156.     BMT_status.bat_full = KAL_FALSE;  
  157.     BMT_status.nPercent_ZCV = 0;  
  158.     BMT_status.nPrecent_UI_SOC_check_point = battery_meter_get_battery_nPercent_UI_SOC();  
  159.   
  160. #if defined(CONFIG_MTK_DUAL_INPUT_CHARGER_SUPPORT)  
  161.     dual_input_init();  
  162. #endif  
  163.   
  164.     /* battery kernel thread for 10s check and charger in/out event */  
  165.     /* Replace GPT timer by hrtime */  
  166.     battery_kthread_hrtimer_init();  
  167.   
  168.     kthread_run(bat_thread_kthread, NULL, "bat_thread_kthread");  
  169.     battery_log(BAT_LOG_CRTI, "[battery_probe] bat_thread_kthread Done\n");  
  170.   
  171.   
  172.     charger_hv_detect_sw_workaround_init();  
  173.   
  174.   
  175.     /*LOG System Set */  
  176.     init_proc_log();  
  177.   
  178. #else  
  179.     /* keep HW alive */  
  180.     /* charger_hv_detect_sw_workaround_init(); */  
  181. #endif  
  182.     g_bat_init_flag = KAL_TRUE;  
  183.   
  184. #if defined(CONFIG_MTK_DUAL_INPUT_CHARGER_SUPPORT)  
  185.     if ((g_vcdt_irq_delay_flag == KAL_TRUE) || (upmu_is_chr_det() == KAL_TRUE))  
  186.         do_chrdet_int_task();  
  187. #endif  
  188.   
  189.     return 0;  
  190. }  

get_charging_control();//获取bq24296的接口

batt_init_cust_data();//获取dts中配置的电池数据

battery_kthread_hrtimer_init();//初始化高精度定时器，每10s唤醒bat_thread_kthread

kthread_run(bat_thread_kthread, NULL, "bat_thread_kthread");//创建内核线程

ret = power_supply_register(&(dev->dev), &battery_main.psy);//注册电池电源


get_charging_control();指针数组初始化

[cpp]  view plain  copy
  1. typedef signed int(*CHARGING_CONTROL) (CHARGING_CTRL_CMD cmd, void *data);  
  2. CHARGING_CONTROL battery_charging_control;  
  3. static void get_charging_control(void)  
  4. {  
  5.     battery_charging_control = chr_control_interface;  
  6. }  
  7. signed int chr_control_interface(CHARGING_CTRL_CMD cmd, void *data)  
  8. {  
  9.     static signed int init = -1;  
  10.   
  11.     if (init == -1) {  
  12.         init = 0;  
  13.         charging_func[CHARGING_CMD_INIT] = charging_hw_init;  
  14.         charging_func[CHARGING_CMD_DUMP_REGISTER] = charging_dump_register;  
  15.         charging_func[CHARGING_CMD_ENABLE] = charging_enable;  
  16.         charging_func[CHARGING_CMD_SET_CV_VOLTAGE] = charging_set_cv_voltage;  
  17.         charging_func[CHARGING_CMD_GET_CURRENT] = charging_get_current;  
  18.         charging_func[CHARGING_CMD_SET_CURRENT] = charging_set_current;  
  19.         charging_func[CHARGING_CMD_SET_INPUT_CURRENT] = charging_set_input_current;  
  20.         charging_func[CHARGING_CMD_GET_CHARGING_STATUS] =  charging_get_charging_status;  
  21.         charging_func[CHARGING_CMD_RESET_WATCH_DOG_TIMER] = charging_reset_watch_dog_timer;  
  22.         charging_func[CHARGING_CMD_SET_HV_THRESHOLD] = charging_set_hv_threshold;  
  23.         charging_func[CHARGING_CMD_GET_HV_STATUS] = charging_get_hv_status;  
  24.         charging_func[CHARGING_CMD_GET_BATTERY_STATUS] = charging_get_battery_status;  
  25.         charging_func[CHARGING_CMD_GET_CHARGER_DET_STATUS] = charging_get_charger_det_status;  
  26.         charging_func[CHARGING_CMD_GET_CHARGER_TYPE] = charging_get_charger_type;  
  27.         charging_func[CHARGING_CMD_SET_PLATFORM_RESET] = charging_set_platform_reset;  
  28.         charging_func[CHARGING_CMD_GET_PLATFORM_BOOT_MODE] = charging_get_platform_boot_mode;  
  29.         charging_func[CHARGING_CMD_SET_POWER_OFF] = charging_set_power_off;  
  30.         charging_func[CHARGING_CMD_SET_TA_CURRENT_PATTERN] = charging_set_ta_current_pattern;  
  31.         charging_func[CHARGING_CMD_SET_ERROR_STATE] = charging_set_error_state;  
  32.         charging_func[CHARGING_CMD_DISO_INIT] = charging_diso_init;  
  33.         charging_func[CHARGING_CMD_GET_DISO_STATE] = charging_get_diso_state;  
  34.         charging_func[CHARGING_CMD_SET_VBUS_OVP_EN] = charging_set_vbus_ovp_en;  
  35.         charging_func[CHARGING_CMD_SET_VINDPM] = charging_set_vindpm;  
  36.     }  
  37.   
  38.     if (cmd < CHARGING_CMD_NUMBER) {  
  39.         if (charging_func[cmd] != NULL)  
  40.             return charging_func[cmd](data);  
  41.     }  
  42.   
  43.     pr_debug("[%s]UNSUPPORT Function: %d\n", __func__, cmd);  
  44.   
  45.     return STATUS_UNSUPPORTED;  
  46. }  

power_supply_register(&(dev->dev), &battery_main.psy);

上层要获取电池属性，相当于直接获取全局结构体battery_data的值。

[cpp]  view plain  copy
  1. struct battery_data {  
  2.     struct power_supply psy;  
  3.     int BAT_STATUS;  
  4.     int BAT_HEALTH;  
  5.     int BAT_PRESENT;  
  6.     int BAT_TECHNOLOGY;  
  7.     int BAT_CAPACITY;  
  8.     /* Add for Battery Service */  
  9.     int BAT_batt_vol;  
  10.     int BAT_batt_temp;  
  11.     /* Add for EM */  
  12.     int BAT_TemperatureR;  
  13.     int BAT_TempBattVoltage;  
  14.     int BAT_InstatVolt;  
  15.     int BAT_BatteryAverageCurrent;  
  16.     int BAT_BatterySenseVoltage;  
  17.     int BAT_ISenseVoltage;  
  18.     int BAT_ChargerVoltage;  
  19.     /* Dual battery */  
  20.     int status_smb;  
  21.     int capacity_smb;  
  22.     int present_smb;  
  23.     int adjust_power;  
  24. };  
  25.   
  26. static enum power_supply_property battery_props[] = {  
  27.     POWER_SUPPLY_PROP_STATUS,  
  28.     POWER_SUPPLY_PROP_HEALTH,  
  29.     POWER_SUPPLY_PROP_PRESENT,  
  30.     POWER_SUPPLY_PROP_TECHNOLOGY,  
  31.     POWER_SUPPLY_PROP_CAPACITY,  
  32.     /* Add for Battery Service */  
  33.     POWER_SUPPLY_PROP_batt_vol,  
  34.     POWER_SUPPLY_PROP_batt_temp,  
  35.     /* Add for EM */  
  36.     POWER_SUPPLY_PROP_TemperatureR,  
  37.     POWER_SUPPLY_PROP_TempBattVoltage,  
  38.     POWER_SUPPLY_PROP_InstatVolt,  
  39.     POWER_SUPPLY_PROP_BatteryAverageCurrent,  
  40.     POWER_SUPPLY_PROP_BatterySenseVoltage,  
  41.     POWER_SUPPLY_PROP_ISenseVoltage,  
  42.     POWER_SUPPLY_PROP_ChargerVoltage,  
  43.     /* Dual battery */  
  44.     POWER_SUPPLY_PROP_status_smb,  
  45.     POWER_SUPPLY_PROP_capacity_smb,  
  46.     POWER_SUPPLY_PROP_present_smb,  
  47.     /* ADB CMD Discharging */  
  48.     POWER_SUPPLY_PROP_adjust_power,  
  49. };   
  50.   
  51. static int battery_get_property(struct power_supply *psy,  
  52.                 enum power_supply_property psp, union power_supply_propval *val)  
  53. {  
  54.     int ret = 0;  
  55.     struct battery_data *data = container_of(psy, struct battery_data, psy);  
  56.   
  57.     switch (psp) {  
  58.     case POWER_SUPPLY_PROP_STATUS:  
  59.         val->intval = data->BAT_STATUS;  
  60.         break;  
  61.     case POWER_SUPPLY_PROP_HEALTH:  
  62.         val->intval = data->BAT_HEALTH;  
  63.         break;  
  64.     case POWER_SUPPLY_PROP_PRESENT:  
  65.         val->intval = data->BAT_PRESENT;  
  66.         break;  
  67.     case POWER_SUPPLY_PROP_TECHNOLOGY:  
  68.         val->intval = data->BAT_TECHNOLOGY;  
  69.         break;  
  70.     case POWER_SUPPLY_PROP_CAPACITY:  
  71.         val->intval = data->BAT_CAPACITY;  
  72.         break;  
  73.     case POWER_SUPPLY_PROP_batt_vol:  
  74.         val->intval = data->BAT_batt_vol;  
  75.         break;  
  76.     case POWER_SUPPLY_PROP_batt_temp:  
  77.         val->intval = data->BAT_batt_temp;  
  78.         break;  
  79.     case POWER_SUPPLY_PROP_TemperatureR:  
  80.         val->intval = data->BAT_TemperatureR;  
  81.         break;  
  82.     case POWER_SUPPLY_PROP_TempBattVoltage:  
  83.         val->intval = data->BAT_TempBattVoltage;  
  84.         break;  
  85.     case POWER_SUPPLY_PROP_InstatVolt:  
  86.         val->intval = data->BAT_InstatVolt;  
  87.         break;  
  88.     case POWER_SUPPLY_PROP_BatteryAverageCurrent:  
  89.         val->intval = data->BAT_BatteryAverageCurrent;  
  90.         break;  
  91.     case POWER_SUPPLY_PROP_BatterySenseVoltage:  
  92.         val->intval = data->BAT_BatterySenseVoltage;  
  93.         break;  
  94.     case POWER_SUPPLY_PROP_ISenseVoltage:  
  95.         val->intval = data->BAT_ISenseVoltage;  
  96.         break;  
  97.     case POWER_SUPPLY_PROP_ChargerVoltage:  
  98.         val->intval = data->BAT_ChargerVoltage;  
  99.         break;  
  100.         /* Dual battery */  
  101.     case POWER_SUPPLY_PROP_status_smb:  
  102.         val->intval = data->status_smb;  
  103.         break;  
  104.     case POWER_SUPPLY_PROP_capacity_smb:  
  105.         val->intval = data->capacity_smb;  
  106.         break;  
  107.     case POWER_SUPPLY_PROP_present_smb:  
  108.         val->intval = data->present_smb;  
  109.         break;  
  110.     case POWER_SUPPLY_PROP_adjust_power:  
  111.         val->intval = data->adjust_power;  
  112.         break;  
  113.   
  114.     default:  
  115.         ret = -EINVAL;  
  116.         break;  
  117.     }  
  118.   
  119.     return ret;  
  120. }  
  121.   
  122. /* battery_data initialization */  
  123. static struct battery_data battery_main = {  
  124.     .psy = {  
  125.         .name = "battery",  
  126.         .type = POWER_SUPPLY_TYPE_BATTERY,  
  127.         .properties = battery_props,  
  128.         .num_properties = ARRAY_SIZE(battery_props),  
  129.         .get_property = battery_get_property,  
  130.         },  
  131. /* CC: modify to have a full power supply status */  
  132. #if defined(CONFIG_POWER_EXT)  
  133.     .BAT_STATUS = POWER_SUPPLY_STATUS_FULL,  
  134.     .BAT_HEALTH = POWER_SUPPLY_HEALTH_GOOD,  
  135.     .BAT_PRESENT = 1,  
  136.     .BAT_TECHNOLOGY = POWER_SUPPLY_TECHNOLOGY_LION,  
  137.     .BAT_CAPACITY = 100,  
  138.     .BAT_batt_vol = 4200,  
  139.     .BAT_batt_temp = 22,  
  140.     /* Dual battery */  
  141.     .status_smb = POWER_SUPPLY_STATUS_NOT_CHARGING,  
  142.     .capacity_smb = 50,  
  143.     .present_smb = 0,  
  144.     /* ADB CMD discharging */  
  145.     .adjust_power = -1,  
  146. #else  
  147.     .BAT_STATUS = POWER_SUPPLY_STATUS_NOT_CHARGING,  
  148.     .BAT_HEALTH = POWER_SUPPLY_HEALTH_GOOD,  
  149.     .BAT_PRESENT = 1,  
  150.     .BAT_TECHNOLOGY = POWER_SUPPLY_TECHNOLOGY_LION,  
  151. #if defined(PUMP_EXPRESS_SERIES)  
  152.     .BAT_CAPACITY = -1,  
  153. #else  
  154.     .BAT_CAPACITY = 50,  
  155. #endif  
  156.     .BAT_batt_vol = 0,  
  157.     .BAT_batt_temp = 0,  
  158.     /* Dual battery */  
  159.     .status_smb = POWER_SUPPLY_STATUS_NOT_CHARGING,  
  160.     .capacity_smb = 50,  
  161.     .present_smb = 0,  
  162.     /* ADB CMD discharging */  
  163.     .adjust_power = -1,  
  164. #endif  
  165. };  


下面看下电池线程函数

[cpp]  view plain  copy
  1. void BAT_thread(void)  
  2. {  
  3.     static kal_bool battery_meter_initilized = KAL_FALSE;  
  4.     static int first_time_update;  
  5.   
  6.     if (battery_meter_initilized == KAL_FALSE) {  
  7.         battery_meter_initial();    /* move from battery_probe() to decrease booting time */  
  8.         BMT_status.nPercent_ZCV = battery_meter_get_battery_nPercent_zcv();  
  9.         battery_meter_initilized = KAL_TRUE;  
  10.     }  
  11.   
  12.     mt_battery_charger_detect_check();  
  13.     if (fg_battery_shutdown)  
  14.         return;  
  15.   
  16.     mt_battery_GetBatteryData();  
  17.     if (fg_battery_shutdown)  
  18.         return;  
  19.   
  20.     if (BMT_status.charger_exist == KAL_TRUE)  
  21.         check_battery_exist();  
  22.   
  23.     mt_battery_thermal_check();  
  24.     mt_battery_notify_check();  
  25.   
  26.     if (first_time_update == 0) {  
  27.         mt_battery_update_status();  
  28.         if (BMT_status.charger_exist == KAL_TRUE) {  
  29.             mt_battery_CheckBatteryStatus();  
  30.             mt_battery_charging_algorithm();  
  31.         }  
  32.         first_time_update = 1;  
  33.     } else {  
  34.         if (BMT_status.charger_exist == KAL_TRUE && !fg_battery_shutdown) {  
  35.             mt_battery_CheckBatteryStatus();  
  36.             mt_battery_charging_algorithm();  
  37.         }  
  38.         mt_battery_update_status();  
  39.     }  
  40.   
  41.     mt_kpoc_power_off_check();  
  42. }  
  43.   
  44.   
  45. int bat_thread_kthread(void *x)  
  46. {  
  47.     ktime_t ktime = ktime_set(3, 0);    /* 10s, 10* 1000 ms */  
  48.     /* Run on a process content */  
  49.     while (!fg_battery_shutdown) {  
  50.         mutex_lock(&bat_mutex);  
  51.   
  52.         if (((chargin_hw_init_done == KAL_TRUE) && (battery_suspended == KAL_FALSE))  
  53.             || ((chargin_hw_init_done == KAL_TRUE) && (fg_wake_up_bat == KAL_TRUE)))  
  54.             BAT_thread();  
  55.   
  56.         mutex_unlock(&bat_mutex);  
  57.   
  58. #ifdef FG_BAT_INT  
  59.         if (fg_wake_up_bat == KAL_TRUE) {  
  60.             wake_unlock(&battery_fg_lock);  
  61.             fg_wake_up_bat = KAL_FALSE;  
  62.             battery_log(BAT_LOG_CRTI, "unlock battery_fg_lock\n");  
  63.         }  
  64. #endif              /* #ifdef FG_BAT_INT */  
  65.   
  66.         battery_log(BAT_LOG_FULL, "wait event\n");  
  67.   
  68.         wait_event(bat_thread_wq, (bat_thread_timeout == KAL_TRUE));  
  69.   
  70.         bat_thread_timeout = KAL_FALSE;  
  71.         hrtimer_start(&battery_kthread_timer, ktime, HRTIMER_MODE_REL);  
  72.         /* 10s, 10* 1000 ms */  
  73.         if (!fg_battery_shutdown)  
  74.             ktime = ktime_set(BAT_TASK_PERIOD, 0);  
  75.   
  76.         if (chr_wake_up_bat == KAL_TRUE && g_smartbook_update != 1) {   /* for charger plug in/ out */  
  77. #if defined(CONFIG_MTK_DUAL_INPUT_CHARGER_SUPPORT)  
  78.             if (DISO_data.chr_get_diso_state) {  
  79.                 DISO_data.chr_get_diso_state = KAL_FALSE;  
  80.                 battery_charging_control(CHARGING_CMD_GET_DISO_STATE, &DISO_data);  
  81.             }  
  82. #endif  
  83.   
  84.             g_smartbook_update = 0;  
  85.             battery_meter_reset();  
  86.             chr_wake_up_bat = KAL_FALSE;  
  87.   
  88.             battery_log(BAT_LOG_CRTI,  
  89.                     "[BATTERY] Charger plug in/out, Call battery_meter_reset. (%d)\n",  
  90.                     BMT_status.UI_SOC);  
  91.         }  
  92.   
  93.     }  
  94.   
  95.     mutex_lock(&bat_mutex);  
  96.     fg_bat_thread = KAL_TRUE;  
  97.     mutex_unlock(&bat_mutex);  
  98.   
  99.     return 0;  
  100. }  

mt_battery_charger_detect_check//检测充电器的类型
mt_battery_GetBatteryData()//获取电池数据
mt_battery_thermal_check()/电池温度检查
mt_battery_notify_check();//电池其他参数检查
mt_battery_charging_algorithm();充电算法(充电硬件初始化，选择充电电流)
mt_battery_update_status()//更新电池数据


mt_battery_GetBatteryData

[cpp]  view plain  copy
  1. void mt_battery_GetBatteryData(void)  
  2. {  
  3.     unsigned int bat_vol, charger_vol, Vsense, ZCV;  
  4.     signed int ICharging, temperature, temperatureR, temperatureV, SOC;  
  5.     static signed int bat_sum, icharging_sum, temperature_sum;  
  6.     static signed int batteryVoltageBuffer[BATTERY_AVERAGE_SIZE];  
  7.     static signed int batteryCurrentBuffer[BATTERY_AVERAGE_SIZE];  
  8.     static signed int batteryTempBuffer[BATTERY_AVERAGE_SIZE];  
  9.     static unsigned char batteryIndex;  
  10.     static signed int previous_SOC = -1;  
  11.     kal_bool current_sign;  
  12.   
  13.     bat_vol = battery_meter_get_battery_voltage(KAL_TRUE);  
  14.     Vsense = battery_meter_get_VSense();  
  15.     if (upmu_is_chr_det() == KAL_TRUE)  
  16.         ICharging = battery_meter_get_charging_current();  
  17.     else  
  18.         ICharging = 0;  
  19.   
  20.   
  21.     charger_vol = battery_meter_get_charger_voltage();  
  22.     temperature = battery_meter_get_battery_temperature();  
  23.     temperatureV = battery_meter_get_tempV();  
  24.     temperatureR = battery_meter_get_tempR(temperatureV);  
  25.   
  26.     if (bat_meter_timeout == KAL_TRUE || bat_spm_timeout == TRUE || fg_wake_up_bat == KAL_TRUE) {  
  27.         SOC = battery_meter_get_battery_percentage();  
  28.         /* if (bat_spm_timeout == true) */  
  29.         /* BMT_status.UI_SOC = battery_meter_get_battery_percentage(); */  
  30.   
  31.         bat_meter_timeout = KAL_FALSE;  
  32.         bat_spm_timeout = FALSE;  
  33.     } else {  
  34.         if (previous_SOC == -1)  
  35.             SOC = battery_meter_get_battery_percentage();  
  36.         else  
  37.             SOC = previous_SOC;  
  38.     }  
  39.   
  40.     ZCV = battery_meter_get_battery_zcv();  
  41.   
  42.     BMT_status.ICharging =  
  43.         mt_battery_average_method(BATTERY_AVG_CURRENT, &batteryCurrentBuffer[0], ICharging,  
  44.                       &icharging_sum, batteryIndex);  
  45.   
  46.   
  47.     if (previous_SOC == -1 && bat_vol <= batt_cust_data.v_0percent_tracking) {  
  48.         battery_log(BAT_LOG_CRTI,  
  49.                 "battery voltage too low, use ZCV to init average data.\n");  
  50.         BMT_status.bat_vol =  
  51.             mt_battery_average_method(BATTERY_AVG_VOLT, &batteryVoltageBuffer[0], ZCV,  
  52.                           &bat_sum, batteryIndex);  
  53.     } else {  
  54.         BMT_status.bat_vol =  
  55.             mt_battery_average_method(BATTERY_AVG_VOLT, &batteryVoltageBuffer[0], bat_vol,  
  56.                           &bat_sum, batteryIndex);  
  57.     }  
  58.   
  59.   
  60.     if (battery_cmd_thermal_test_mode == 1) {  
  61.         battery_log(BAT_LOG_CRTI, "test mode , battery temperature is fixed.\n");  
  62.     } else {  
  63.         BMT_status.temperature =  
  64.             mt_battery_average_method(BATTERY_AVG_TEMP, &batteryTempBuffer[0], temperature,  
  65.                           &temperature_sum, batteryIndex);  
  66.     }  
  67.   
  68.   
  69.     BMT_status.Vsense = Vsense;  
  70.     BMT_status.charger_vol = charger_vol;  
  71.     BMT_status.temperatureV = temperatureV;  
  72.     BMT_status.temperatureR = temperatureR;  
  73.     BMT_status.SOC = SOC;  
  74.     BMT_status.ZCV = ZCV;  
  75.     BMT_status.IBattery = battery_meter_get_battery_current();  
  76.     current_sign = battery_meter_get_battery_current_sign();  
  77.     BMT_status.IBattery *= (current_sign ? 1 : (-1));  
  78.   
  79.     if (BMT_status.charger_exist == KAL_FALSE) {  
  80.         if (BMT_status.SOC > previous_SOC && previous_SOC >= 0)  
  81.             BMT_status.SOC = previous_SOC;  
  82.     }  
  83.   
  84.   
  85.     previous_SOC = BMT_status.SOC;  
  86.   
  87.     batteryIndex++;  
  88.     if (batteryIndex >= BATTERY_AVERAGE_SIZE)  
  89.         batteryIndex = 0;  
  90.   
  91.   
  92.     if (g_battery_soc_ready == KAL_FALSE)  
  93.         g_battery_soc_ready = KAL_TRUE;  
  94.   
  95.     battery_log(BAT_LOG_CRTI,  
  96.     "AvgVbat=(%d,%d),AvgI=(%d,%d),VChr=%d,AvgT=(%d,%d),SOC=(%d,%d),UI_SOC=%d,ZCV=%d,CHR_Type=%d bcct:%d:%d I:%d Ibat:%d\n",  
  97.             BMT_status.bat_vol, bat_vol, BMT_status.ICharging, ICharging,  
  98.             BMT_status.charger_vol, BMT_status.temperature, temperature,  
  99.             previous_SOC, BMT_status.SOC, BMT_status.UI_SOC, BMT_status.ZCV,  
  100.             BMT_status.charger_type, g_bcct_flag, get_usb_current_unlimited(),  
  101.             get_bat_charging_current_level(), BMT_status.IBattery / 10);  
  102.     battery_log(BAT_LOG_CRTI, "v=%d,i=%d,t=%d,soc=%d,bcct:%d:%d I:%d Ibat:%d\n",  
  103.             bat_vol, ICharging, temperature, BMT_status.UI_SOC, g_bcct_flag,  
  104.             get_usb_current_unlimited(), get_bat_charging_current_level(),  
  105.             BMT_status.IBattery / 10);  
  106.   
  107. }  
battery_meter_get_battery_percentage　//获取电池电量(方式１通过开路电压与容量的关系　方式2根据开路电压算出初始电量,然后通过库伦积分算出消耗的电量)
BMT_status.bat_vol, bat_vol,　　　　 //该段时间的平均电池电压　　//电池电压(直接读寄存器)
BMT_status.ICharging　　 　　　　　//电流(平台硬件差异这里是0,这里通过的是库仑计获取电流)
BMT_status.charger_vol  　　　　　　//充电器电压  根据pmic6328vcdt脚获取到的电压，根据分压原理算出vbus的电压　其中vcdt还有一个功能，
作为充电器的中断检测，来判断充电器的插拔
BMT_status.temperature, temperature,　//电池温度
BMT_status.SOC, BMT_status.UI_SOC　//电池容量　　电池ui容量
BMT_status.ZCV//电路开路电压
BMT_status.charger_type//充电器类型
g_bcct_flag//充电是否被限流(高温或者其他情况)　　
get_bat_charging_current_level(), //获取充电电流等级（bq24296对应的值）


mt_battery_update_status//更新全局结构体battery_data的值，上层便能及时获取到电池的数据

[cpp]  view plain  copy
  1. static void mt_battery_update_status(void)  
  2. {  
  3. #if defined(CONFIG_POWER_EXT)  
  4.     battery_log(BAT_LOG_CRTI, "[BATTERY] CONFIG_POWER_EXT, no update Android.\n");  
  5. #else  
  6.     {  
  7.         if (skip_battery_update == KAL_FALSE) {  
  8.             battery_log(BAT_LOG_FULL, "mt_battery_update_status.\n");  
  9.             usb_update(&usb_main);  
  10.             ac_update(&ac_main);  
  11.             wireless_update(&wireless_main);  
  12.             battery_update(&battery_main);  
  13.         } else {  
  14.             battery_log(BAT_LOG_CRTI, "skip mt_battery_update_status.\n");  
  15.             skip_battery_update = KAL_FALSE;  
  16.         }  
  17.     }  
  18.   
  19. #endif  
  20. }  
  21.   
  22. static void battery_update(struct battery_data *bat_data)  
  23. {  
  24.     struct power_supply *bat_psy = &bat_data->psy;  
  25.     kal_bool resetBatteryMeter = KAL_FALSE;  
  26.     static unsigned int update_cnt = 3;  
  27.     static unsigned int pre_uisoc;  
  28.     static unsigned int pre_chr_state;  
  29.   
  30.     bat_data->BAT_TECHNOLOGY = POWER_SUPPLY_TECHNOLOGY_LION;  
  31.     bat_data->BAT_HEALTH = POWER_SUPPLY_HEALTH_GOOD;  
  32.     bat_data->BAT_batt_vol = BMT_status.bat_vol;  
  33.     bat_data->BAT_batt_temp = BMT_status.temperature * 10;  
  34.     bat_data->BAT_PRESENT = BMT_status.bat_exist;  
  35.   
  36.     if ((BMT_status.charger_exist == KAL_TRUE) && (BMT_status.bat_charging_state != CHR_ERROR)) {  
  37.         if (BMT_status.bat_exist) {    /* charging */  
  38.             if (BMT_status.bat_vol <= batt_cust_data.v_0percent_tracking)  
  39.                 resetBatteryMeter = mt_battery_0Percent_tracking_check();  
  40.             else  
  41.                 resetBatteryMeter = mt_battery_100Percent_tracking_check();  
  42.   
  43.   
  44.             bat_data->BAT_STATUS = POWER_SUPPLY_STATUS_CHARGING;  
  45.         } else {    /* No Battery, Only Charger */  
  46.   
  47.             bat_data->BAT_STATUS = POWER_SUPPLY_STATUS_UNKNOWN;  
  48.             BMT_status.UI_SOC = 0;  
  49.         }  
  50.   
  51.     } else {        /* Only Battery */  
  52.   
  53.         bat_data->BAT_STATUS = POWER_SUPPLY_STATUS_NOT_CHARGING;  
  54.         if (BMT_status.bat_vol <= batt_cust_data.v_0percent_tracking)  
  55.             resetBatteryMeter = mt_battery_0Percent_tracking_check();  
  56.         else  
  57.             resetBatteryMeter = mt_battery_nPercent_tracking_check();  
  58.     }  
  59.   
  60.     if (resetBatteryMeter == KAL_TRUE) {  
  61.         battery_meter_reset();  
  62.     } else {  
  63.         if (BMT_status.bat_full == KAL_TRUE && is_uisoc_ever_100 == KAL_TRUE) {  
  64.             BMT_status.UI_SOC = 100;  
  65.             battery_log(BAT_LOG_CRTI, "[recharging] UI_SOC=%d, SOC=%d\n",  
  66.                     BMT_status.UI_SOC, BMT_status.SOC);  
  67.         } else {  
  68.             mt_battery_Sync_UI_Percentage_to_Real();  
  69.         }  
  70.     }  
  71.   
  72.     battery_log(BAT_LOG_CRTI, "UI_SOC=(%d), resetBatteryMeter=(%d)\n",  
  73.             BMT_status.UI_SOC, resetBatteryMeter);  
  74.   
  75.   
  76.     /* set RTC SOC to 1 to avoid SOC jump in charger boot.*/  
  77.     if (BMT_status.UI_SOC <= 1)  
  78.         set_rtc_spare_fg_value(1);  
  79.     else  
  80.         set_rtc_spare_fg_value(BMT_status.UI_SOC);  
  81.   
  82.   
  83.     mt_battery_update_EM(bat_data);  
  84.   
  85.     if (cmd_discharging == 1)  
  86.         bat_data->BAT_STATUS = POWER_SUPPLY_STATUS_CMD_DISCHARGING;  
  87.   
  88.     if (adjust_power != -1) {  
  89.         bat_data->adjust_power = adjust_power;  
  90.         battery_log(BAT_LOG_CRTI, "adjust_power=(%d)\n", adjust_power);  
  91.     }  
  92. #ifdef DLPT_POWER_OFF_EN  
  93.     /*extern int dlpt_check_power_off(void);*/  
  94.     if (bat_data->BAT_CAPACITY <= DLPT_POWER_OFF_THD) {  
  95.         static signed char cnt;  
  96.   
  97.         battery_log(BAT_LOG_CRTI, "[DLPT_POWER_OFF_EN] run\n");  
  98.   
  99.         if (dlpt_check_power_off() == 1) {  
  100.             bat_data->BAT_CAPACITY = 0;  
  101.             cnt++;  
  102.             battery_log(BAT_LOG_CRTI, "[DLPT_POWER_OFF_EN] SOC=%d to power off\n",  
  103.                     bat_data->BAT_CAPACITY);  
  104.             if (cnt >= 2)  
  105.                 kernel_restart("DLPT reboot system");  
  106.   
  107.         } else  
  108.             cnt = 0;  
  109.     } else {  
  110.         battery_log(BAT_LOG_CRTI, "[DLPT_POWER_OFF_EN] disable(%d)\n",  
  111.                 bat_data->BAT_CAPACITY);  
  112.     }  
  113. #endif  
  114.   
  115.     if (update_cnt >= 3) {  
  116.         /* Update per 60 seconds */  
  117.         power_supply_changed(bat_psy);  
  118.         pre_uisoc = BMT_status.UI_SOC;  
  119.         update_cnt = 0;  
  120.         pre_chr_state = BMT_status.bat_charging_state;  
  121.         if (cable_in_uevent == 1)  
  122.             cable_in_uevent = 0;  
  123.     } else if ((pre_uisoc != BMT_status.UI_SOC) || (BMT_status.UI_SOC == 0)) {  
  124.         /* Update when soc change */  
  125.         power_supply_changed(bat_psy);  
  126.         pre_uisoc = BMT_status.UI_SOC;  
  127.         update_cnt = 0;  
  128.     } else if ((BMT_status.charger_exist == KAL_TRUE) &&  
  129.             ((pre_chr_state != BMT_status.bat_charging_state) ||  
  130.             (BMT_status.bat_charging_state == CHR_ERROR))) {  
  131.         /* Update when changer status change */  
  132.         power_supply_changed(bat_psy);  
  133.         pre_chr_state = BMT_status.bat_charging_state;  
  134.         update_cnt = 0;  
  135.     } else if (cable_in_uevent == 1) {  
  136.         /*To prevent interrupt-trigger update from being filtered*/  
  137.         power_supply_changed(bat_psy);  
  138.         cable_in_uevent = 0;  
  139.     } else {  
  140.         /* No update */  
  141.         update_cnt++;  
  142.     }  
  143. }  
mt_battery_0Percent_tracking_check//低于关机电压监测，让ui电池容量减少到0,这时framework层会让系统关机
mt_battery_nPercent_tracking_check//n可自行定制，库仑积分计算的电量跟ocv(开路电压)计算的电量进行同步，保证电量计算的可靠性。
mt_battery_Sync_UI_Percentage_to_Real();//同步ui显示的电量百分比

MTK无电池方案修改
09-14 1483
MTK无电池方案修改，通过开关配置，不需要修改代码
batterylog电池记录工具
09-23
batterylog电池记录工具batterylog电池记录工具
MTK 充电知识
cktrobin的博客
01-14 4562
相关概念 懒的排版了，直接上图 相关文件关系 再来一发 杂项，电池温度检测原理图 发 充电流程 图样图森破 核心函数特写 /* 概念: ZCV：开路电压 OCV: 开路电压 VC：闭路电压 CAR：库伦计 DOD: 放电深度，100-DOD 即电容容量 Cmax/Qmax: 电池容量 相关文件关系: Battery_common.c (s:\i841\mediatek\k...
MTK Battery系统
lansehai的专栏
10-07 1万+
MTK方案的电池充电过程分为预充、恒流充电（CC模式）、恒压充电（CV模式）三种模式，整个充电过程如下充电状态图所示：       MTK充电的整个过程都可以从这个充电状态图看出来，刚开始充电的时候，代码先判断是插USB充电还是差ac充电，电池在进入充电阶段分为快速充电、CC（恒流充电）、CV（恒压充电）。而从CC模式切换到CV模式在代码中的alps/mediatek/kernel/dr
8-18节串联电池组保护芯片 MT9818.pdf
06-18
芯片的测量功能非常全面，包含16位电池包总电压测量、温度监测、电池保护等，同时对放电过流和短路、过压和欠压等异常状态进行报警处理。MT9818还提供了均衡功能，以确保电池组在充电时的电压一致性，进而延长电池组...
MT9818 8-18串模拟前端AFE电池保护芯片 私信获得完整文件
11-24
2. **储能系统**：如太阳能储能设备，需要准确测量电池状态，防止过充或过放。 3. **便携式设备**：例如无人机，通过高效电池管理提升飞行时间和安全性。 4. **工业设备**：在一些大功率工业设备中，多节电池串联...
MT1430电池保护芯片：一体化解决方案与数据手册
3. 充电检测功能：监控电池的充电状态，防止过充，以保持电池健康并防止潜在危险。 4. 过充电流检测：在电池充电过程中，如果电流超过预设阈值，芯片会切断充电路径，防止电池过度充电。 5. 内部延迟时间生成：延迟...
MT6392_PMIC_Data_Sheet_V1.0.pdf
10-07
MT6392是一款专为移动设备设计的电源管理解决方案，其主要功能包括电压调节、电流监控、电池充电管理和系统电源管理等，以确保设备在各种运行条件下的稳定供电。 文档中的"Version 1.0"表示这是该资料的初始版本，...
MT9813低功耗电池管理芯片：18节串联锂电池监控与均衡方案
10. **应用**: MT9813特别适合用于多节串联电池组，如电动车、储能系统、无人机等领域，通过菊链式通信结构可以方便地监测长串电池组的状态。 MT9813芯片以其高效、低功耗、全面的电池管理和安全特性，成为电池管理...
18.mtk 电池流程
老道
04-28 1807
/* 概念:         ZCV：开路电压        OCV: 开路电压        VC：闭路电压        CAR：库伦计        DOD: 放电深度，100-DOD 即电容容量        Cmax/Qmax: 电池容量相关文件关系:        Battery_common.c (s:\i841\mediatek\kernel\drivers\power)     ...
MTK平台下Battery驱动分析及充电流程
richu123的专栏
05-19 1万+
转自：http://blog.youkuaiyun.com/baidu_34021173/article/details/51105223主要涉及代码：Kernel：kernel-3.10\drivers\power\mediatek\kernel-3.10\drivers\misc\mediatek\mach\mt6580\&lt;project_name&gt;\power\MTK Battery框架结构...
MTK 充电逻辑总结
Zorry的专栏
11-01 9851
相关概念 懒的排版了，直接上图  相关文件关系 再来一发  杂项，电池温度检测原理图 发  充电流程 图样图森破  核心函数特写       /* 概念: ZCV：开路电压 OCV: 开路电压 VC：闭路电压 CAR：库伦计
关机屏蔽power键
反思与改变
08-14 3060
android关机过程中如何屏蔽掉power键？小弟在做一个项目，具体如下： 一般情况下长按android 开关机键，会关机，关机的同时屏幕显示关机动画，比如是一个旋转进度动画....正常情况下，关机动画结束，关机完成，屏幕变黑，但是，在关机过程中，即还在播放关机动画时，你如果按power键，会发现屏幕变黑，再点击，屏幕变亮，继续能看到关机动画，现在小弟想做的是在关机过程中屏蔽power键，即在
驱动辅助资料（工具，目录，指令，debug经验）
mark_xue的博客
03-11 5258
1. nohup sleep 6h && make -j24 2>&1 | tee build.log & 然后exit,一直到退出； 2. 第一：拉代码过程，SCM RELEASE邮件里会有的：repo init -u ssh://192.168.10.10/MTK6753_M_X520/manifest -b master -m X521-J5...
MTK LCM调试总结
最新发布
随风的博客
10-20 1387
修改kernel-3.18\drivers\misc\mediatek\lcm\rm68200_dsi_vdo_common\rm68200_dsi_vdo_common.c。mt_mt65xx_led_set_cust(level) // 在此之前 或 disp_aal_notify_backlight_changed(3. 修改Y:\code2\mtk6737_pb5_1_0_cmcc\device\alibaba\b905_lezhou\ProjectConfig.mk。
MTK平台TP驱动详解
热门推荐
www.wowothink.com的专栏
05-10 1万+
MTK平台tp驱动详解本博文将讲解基于goodix9157触控芯片的tp驱动程序。这里有对应的驱动程序。初始化static int __init tpd_driver_init(void) { GTP_INFO("MediaTek gt91xx touch panel driver init\n"); #if defined(TPD_I2C_NUMBER) i2c_register
基于MTK 的 TP 驱动分析
zhubin0613的专栏
01-03 3245
1. 克隆服务器工程源码并切换分支  git clone git@192.168.20.2: mt658292_kk v9  git checkout -b submit_v9_dongxf_tp_modify_v1.0_2014_0910 origin/v6_dev 2. TP 硬件分析 1）硬件图：   2）硬件管脚：
MTK平台充电调试总结
u012765781的博客
07-13 4681
摘要：调试电池的充放电管理，首先需要深入了解锂电池的电池原理和特点，充放电特性以及基本的电池安全问题。然后需要对MTK的电池管理驱动程序有深入的了解，理解电池充放电算法的基本原理。在此基础上，对充放电导致的问题进行调试优化。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值