drivers/power/mediatek/switch_charging.c

   1 /*****************************************************************************
   2  *
   3  * Filename:
   4  * ---------
   5  *    linear_charging.c
   6  *
   7  * Project:
   8  * --------
   9  *   ALPS_Software
  10  *
  11  * Description:
  12  * ------------
  13  *   This file implements the interface between BMT and ADC scheduler.
  14  *
  15  * Author:
  16  * -------
  17  *  Oscar Liu
  18  *
  19  *============================================================================
  20   * $Revision:   1.0  $
  21  * $Modtime:   11 Aug 2005 10:28:16  $
  22  * $Log:   //mtkvs01/vmdata/Maui_sw/archives/mcu/hal/peripheral/inc/bmt_chr_setting.h-arc  $
  23  *             HISTORY
  24  * Below this line, this part is controlled by PVCS VM. DO NOT MODIFY!!
  25  *------------------------------------------------------------------------------
  26  *------------------------------------------------------------------------------
  27  * Upper this line, this part is controlled by PVCS VM. DO NOT MODIFY!!
  28  *============================================================================
  29  ****************************************************************************/
  30 #include <linux/kernel.h>
  31 #include <mach/battery_common.h>
  32 #include <mach/charging.h>
  33 #include "cust_charging.h"
  34 #include <mach/mt_boot.h>
  35 #include <mach/battery_meter.h>
  36
  37 #if defined(CONFIG_MTK_PUMP_EXPRESS_PLUS_SUPPORT)
  38 #include <linux/mutex.h>
  39 #include <linux/wakelock.h>
  40 #include <linux/delay.h>
  41 #if !defined(TA_AC_CHARGING_CURRENT)
  42 #include "cust_pe.h"
  43 #endif
  44 #endif
  45
  46 #ifdef CONFIG_MTK_DUAL_INPUT_CHARGER_SUPPORT
  47 #include <mach/diso.h>
  48 #endif
  49
  50  /* ============================================================ // */
  51  /* define */
  52  /* ============================================================ // */
  53  /* cut off to full */
  54 #define POST_CHARGING_TIME              30 * 60         /* 30mins */
  55 #define FULL_CHECK_TIMES                6
  56
  57  /* ============================================================ // */
  58  /* global variable */
  59  /* ============================================================ // */
  60 kal_uint32 g_bcct_flag = 0;
  61 kal_uint32 g_bcct_value = 0;
  62 kal_uint32 g_full_check_count = 0;
  63 CHR_CURRENT_ENUM g_temp_CC_value = CHARGE_CURRENT_0_00_MA;
  64 CHR_CURRENT_ENUM g_temp_input_CC_value = CHARGE_CURRENT_0_00_MA;
  65 kal_uint32 g_usb_state = USB_UNCONFIGURED;
  66 static bool usb_unlimited=false;
  67
  68   /* ///////////////////////////////////////////////////////////////////////////////////////// */
  69   /* // PUMP EXPRESS */
  70   /* ///////////////////////////////////////////////////////////////////////////////////////// */
  71 #if defined(CONFIG_MTK_PUMP_EXPRESS_PLUS_SUPPORT)
  72 struct wake_lock TA_charger_suspend_lock;
  73 kal_bool ta_check_chr_type = KAL_TRUE;
  74 kal_bool ta_cable_out_occur = KAL_FALSE;
  75 kal_bool is_ta_connect = KAL_FALSE;
  76 kal_bool ta_vchr_tuning = KAL_TRUE;
  77 int ta_v_chr_org = 0;
  78 #endif
  79
  80   /* ///////////////////////////////////////////////////////////////////////////////////////// */
  81   /* // JEITA */
  82   /* ///////////////////////////////////////////////////////////////////////////////////////// */
  83 #if defined(CONFIG_MTK_JEITA_STANDARD_SUPPORT)
  84 int g_temp_status = TEMP_POS_10_TO_POS_45;
  85 kal_bool temp_error_recovery_chr_flag = KAL_TRUE;
  86 #endif
  87
  88
  89
  90  /* ============================================================ // */
  91  /* function prototype */
  92  /* ============================================================ // */
  93
  94
  95  /* ============================================================ // */
  96  /* extern variable */
  97  /* ============================================================ // */
  98 extern int g_platform_boot_mode;
  99
 100  /* ============================================================ // */
 101  /* extern function */
 102  /* ============================================================ // */
 103
 104
 105  /* ============================================================ // */
 106 void BATTERY_SetUSBState(int usb_state_value)
 107 {
 108 #if defined(CONFIG_POWER_EXT)
 109         battery_xlog_printk(BAT_LOG_CRTI, "[BATTERY_SetUSBState] in FPGA/EVB, no service\r\n");
 110 #else
 111         if ((usb_state_value < USB_SUSPEND) || ((usb_state_value > USB_CONFIGURED))) {
 112                 battery_xlog_printk(BAT_LOG_CRTI,
 113                                     "[BATTERY] BAT_SetUSBState Fail! Restore to default value\r\n");
 114                 usb_state_value = USB_UNCONFIGURED;
 115         } else {
 116                 battery_xlog_printk(BAT_LOG_CRTI, "[BATTERY] BAT_SetUSBState Success! Set %d\r\n",
 117                                     usb_state_value);
 118                 g_usb_state = usb_state_value;
 119         }
 120 #endif
 121 }
 122
 123
 124 kal_uint32 get_charging_setting_current(void)
 125 {
 126         return g_temp_CC_value;
 127 }
 128
 129 #if defined(CONFIG_MTK_PUMP_EXPRESS_PLUS_SUPPORT)
 130 static DEFINE_MUTEX(ta_mutex);
 131
 132 static void set_ta_charging_current(void)
 133 {
 134         int real_v_chrA = 0;
 135
 136         real_v_chrA = battery_meter_get_charger_voltage();
 137         battery_xlog_printk(BAT_LOG_CRTI, "set_ta_charging_current, chrA=%d, chrB=%d\n",
 138                 ta_v_chr_org, real_v_chrA);
 139
 140         if((real_v_chrA - ta_v_chr_org) > 3000) {
 141                 g_temp_input_CC_value = TA_AC_9V_INPUT_CURRENT;  //TA = 9V
 142                 g_temp_CC_value = TA_AC_CHARGING_CURRENT;
 143         } else if((real_v_chrA - ta_v_chr_org) > 1000) {
 144                 g_temp_input_CC_value = TA_AC_7V_INPUT_CURRENT;  //TA = 7V
 145                 g_temp_CC_value = TA_AC_CHARGING_CURRENT;
 146         }
 147 }
 148
 149 static void mtk_ta_reset_vchr(void)
 150 {
 151         CHR_CURRENT_ENUM chr_current = CHARGE_CURRENT_70_00_MA;
 152
 153         battery_charging_control(CHARGING_CMD_SET_INPUT_CURRENT,&chr_current);
 154         msleep(250);    // reset Vchr to 5V
 155
 156         battery_xlog_printk(BAT_LOG_CRTI, "mtk_ta_reset_vchr(): reset Vchr to 5V \n");
 157 }
 158
 159 static void mtk_ta_increase(void)
 160 {
 161         kal_bool ta_current_pattern = KAL_TRUE;  // TRUE = increase
 162
 163         if(ta_cable_out_occur == KAL_FALSE) {
 164                 battery_charging_control(CHARGING_CMD_SET_TA_CURRENT_PATTERN, &ta_current_pattern);
 165         } else {
 166                 ta_check_chr_type = KAL_TRUE;
 167                 battery_xlog_printk(BAT_LOG_CRTI, "mtk_ta_increase() Cable out \n");
 168         }
 169 }
 170
 171 static kal_bool mtk_ta_retry_increase(void)
 172 {
 173         int real_v_chrA;
 174         int real_v_chrB;
 175         kal_bool retransmit = KAL_TRUE;
 176         kal_uint32 retransmit_count=0;
 177
 178         do {
 179                 real_v_chrA = battery_meter_get_charger_voltage();
 180                 mtk_ta_increase();  //increase TA voltage to 7V
 181                 real_v_chrB = battery_meter_get_charger_voltage();
 182
 183                 if(real_v_chrB - real_v_chrA >= 1000) { /* 1.0V */
 184                         retransmit = KAL_FALSE;
 185                 } else {
 186                         retransmit_count++;
 187                         battery_xlog_printk(BAT_LOG_CRTI, "mtk_ta_detector(): retransmit_count =%d, chrA=%d, chrB=%d\n",
 188                                 retransmit_count, real_v_chrA, real_v_chrB);
 189                 }
 190
 191                 if((retransmit_count == 3) || (BMT_status.charger_exist == KAL_FALSE)) {
 192                         retransmit = KAL_FALSE;
 193                 }
 194
 195         } while((retransmit == KAL_TRUE) && (ta_cable_out_occur == KAL_FALSE));
 196
 197         battery_xlog_printk(BAT_LOG_CRTI, "mtk_ta_retry_increase() real_v_chrA=%d, real_v_chrB=%d, retry=%d\n",
 198         real_v_chrA, real_v_chrB,retransmit_count);
 199
 200         if(retransmit_count == 3)
 201                 return KAL_FALSE;
 202         else
 203                 return KAL_TRUE;
 204 }
 205
 206 static void mtk_ta_detector(void)
 207 {
 208         int real_v_chrB = 0;
 209
 210         battery_xlog_printk(BAT_LOG_CRTI, "mtk_ta_detector() start\n");
 211
 212         ta_v_chr_org = battery_meter_get_charger_voltage();
 213         mtk_ta_retry_increase();
 214         real_v_chrB = battery_meter_get_charger_voltage();
 215
 216         if(real_v_chrB - ta_v_chr_org >= 1000)
 217                 is_ta_connect = KAL_TRUE;
 218         else
 219                 is_ta_connect = KAL_FALSE;
 220
 221         battery_xlog_printk(BAT_LOG_CRTI, "mtk_ta_detector() end, is_ta_connect=%d\n",is_ta_connect);
 222 }
 223
 224 static void mtk_ta_init(void)
 225 {
 226         is_ta_connect = KAL_FALSE;
 227         ta_cable_out_occur = KAL_FALSE;
 228
 229 #ifdef TA_9V_SUPPORT
 230         ta_vchr_tuning = KAL_FALSE;
 231 #endif
 232
 233         battery_charging_control(CHARGING_CMD_INIT,NULL);
 234 }
 235
 236 static void battery_pump_express_charger_check(void)
 237 {
 238         if (KAL_TRUE == ta_check_chr_type &&
 239                 STANDARD_CHARGER == BMT_status.charger_type &&
 240                 BMT_status.SOC >= TA_START_BATTERY_SOC &&
 241                 BMT_status.SOC < TA_STOP_BATTERY_SOC) {
 242
 243                 mutex_lock(&ta_mutex);
 244                 wake_lock(&TA_charger_suspend_lock);
 245
 246                 mtk_ta_reset_vchr();
 247
 248                 mtk_ta_init();
 249                 mtk_ta_detector();
 250
 251                 /* need to re-check if the charger plug out during ta detector */
 252                 if(KAL_TRUE == ta_cable_out_occur)
 253                         ta_check_chr_type = KAL_TRUE;
 254                 else
 255                         ta_check_chr_type = KAL_FALSE;
 256
 257                 wake_unlock(&TA_charger_suspend_lock);
 258                 mutex_unlock(&ta_mutex);
 259         } else {
 260                 battery_xlog_printk(BAT_LOG_CRTI,
 261                 "Stop battery_pump_express_charger_check, SOC=%d, ta_check_chr_type = %d, charger_type = %d \n",
 262                 BMT_status.SOC, ta_check_chr_type, BMT_status.charger_type);
 263         }
 264 }
 265
 266 static void battery_pump_express_algorithm_start(void)
 267 {
 268         kal_int32 charger_vol;
 269         kal_uint32 charging_enable = KAL_FALSE;
 270
 271         mutex_lock(&ta_mutex);
 272         wake_lock(&TA_charger_suspend_lock);
 273
 274         if(KAL_TRUE == is_ta_connect) {
 275                 /* check cable impedance */
 276                 charger_vol = battery_meter_get_charger_voltage();
 277                 if(KAL_FALSE == ta_vchr_tuning) {
 278                         mtk_ta_retry_increase();        /* increase TA voltage to 9V */
 279                         charger_vol = battery_meter_get_charger_voltage();
 280                         ta_vchr_tuning = KAL_TRUE;
 281                 } else if(BMT_status.SOC > TA_STOP_BATTERY_SOC) {
 282                         /* disable charging, avoid Iterm issue */
 283                         battery_charging_control(CHARGING_CMD_ENABLE,&charging_enable);
 284                         mtk_ta_reset_vchr();    //decrease TA voltage to 5V
 285                         charger_vol = battery_meter_get_charger_voltage();
 286                         if(abs(charger_vol - ta_v_chr_org) <= 1000)     /* 1.0V */
 287                                 is_ta_connect = KAL_FALSE;
 288
 289                         battery_xlog_printk(BAT_LOG_CRTI, "Stop battery_pump_express_algorithm, SOC=%d is_ta_connect =%d, TA_STOP_BATTERY_SOC: %d\n",
 290                                 BMT_status.SOC, is_ta_connect, TA_STOP_BATTERY_SOC);
 291                 }
 292                 battery_xlog_printk(BAT_LOG_CRTI, "[BATTERY] check cable impedance, VA(%d) VB(%d) delta(%d).\n",
 293                 ta_v_chr_org, charger_vol, charger_vol - ta_v_chr_org);
 294
 295                 battery_xlog_printk(BAT_LOG_CRTI, "mtk_ta_algorithm() end\n");
 296         } else {
 297                 battery_xlog_printk(BAT_LOG_CRTI, "It's not a TA charger, bypass TA algorithm\n");
 298         }
 299
 300         wake_unlock(&TA_charger_suspend_lock);
 301         mutex_unlock(&ta_mutex);
 302 }
 303 #endif
 304
 305 #if defined(CONFIG_MTK_JEITA_STANDARD_SUPPORT)
 306
 307 static BATTERY_VOLTAGE_ENUM select_jeita_cv(void)
 308 {
 309         BATTERY_VOLTAGE_ENUM cv_voltage;
 310
 311         if (g_temp_status == TEMP_ABOVE_POS_60) {
 312                 cv_voltage = JEITA_TEMP_ABOVE_POS_60_CV_VOLTAGE;
 313         } else if (g_temp_status == TEMP_POS_45_TO_POS_60) {
 314                 cv_voltage = JEITA_TEMP_POS_45_TO_POS_60_CV_VOLTAGE;
 315         } else if (g_temp_status == TEMP_POS_10_TO_POS_45) {
 316 #ifdef HIGH_BATTERY_VOLTAGE_SUPPORT
 317                 cv_voltage = BATTERY_VOLT_04_340000_V;
 318 #else
 319                 cv_voltage = JEITA_TEMP_POS_10_TO_POS_45_CV_VOLTAGE;
 320 #endif
 321         } else if (g_temp_status == TEMP_POS_0_TO_POS_10) {
 322                 cv_voltage = JEITA_TEMP_POS_0_TO_POS_10_CV_VOLTAGE;
 323         } else if (g_temp_status == TEMP_NEG_10_TO_POS_0) {
 324                 cv_voltage = JEITA_TEMP_NEG_10_TO_POS_0_CV_VOLTAGE;
 325         } else if (g_temp_status == TEMP_BELOW_NEG_10) {
 326                 cv_voltage = JEITA_TEMP_BELOW_NEG_10_CV_VOLTAGE;
 327         } else {
 328                 cv_voltage = BATTERY_VOLT_04_200000_V;
 329         }
 330
 331         return cv_voltage;
 332 }
 333
 334 PMU_STATUS do_jeita_state_machine(void)
 335 {
 336         BATTERY_VOLTAGE_ENUM cv_voltage;
 337
 338         /* JEITA battery temp Standard */
 339
 340         if (BMT_status.temperature >= TEMP_POS_60_THRESHOLD) {
 341                 battery_xlog_printk(BAT_LOG_CRTI,
 342                                     "[BATTERY] Battery Over high Temperature(%d) !!\n\r",
 343                                     TEMP_POS_60_THRESHOLD);
 344
 345                 g_temp_status = TEMP_ABOVE_POS_60;
 346
 347                 return PMU_STATUS_FAIL;
 348         } else if (BMT_status.temperature > TEMP_POS_45_THRESHOLD)      /* control 45c to normal behavior */
 349         {
 350                 if ((g_temp_status == TEMP_ABOVE_POS_60)
 351                     && (BMT_status.temperature >= TEMP_POS_60_THRES_MINUS_X_DEGREE)) {
 352                         battery_xlog_printk(BAT_LOG_CRTI,
 353                                             "[BATTERY] Battery Temperature between %d and %d,not allow charging yet!!\n\r",
 354                                             TEMP_POS_60_THRES_MINUS_X_DEGREE,
 355                                             TEMP_POS_60_THRESHOLD);
 356
 357                         return PMU_STATUS_FAIL;
 358                 } else {
 359                         battery_xlog_printk(BAT_LOG_CRTI,
 360                                             "[BATTERY] Battery Temperature between %d and %d !!\n\r",
 361                                             TEMP_POS_45_THRESHOLD, TEMP_POS_60_THRESHOLD);
 362
 363                         g_temp_status = TEMP_POS_45_TO_POS_60;
 364                 }
 365         } else if (BMT_status.temperature >= TEMP_POS_10_THRESHOLD) {
 366                 if (((g_temp_status == TEMP_POS_45_TO_POS_60)
 367                      && (BMT_status.temperature >= TEMP_POS_45_THRES_MINUS_X_DEGREE))
 368                     || ((g_temp_status == TEMP_POS_0_TO_POS_10)
 369                         && (BMT_status.temperature <= TEMP_POS_10_THRES_PLUS_X_DEGREE))) {
 370                         battery_xlog_printk(BAT_LOG_CRTI,
 371                                             "[BATTERY] Battery Temperature not recovery to normal temperature charging mode yet!!\n\r");
 372                 } else {
 373                         battery_xlog_printk(BAT_LOG_CRTI,
 374                                             "[BATTERY] Battery Normal Temperature between %d and %d !!\n\r",
 375                                             TEMP_POS_10_THRESHOLD, TEMP_POS_45_THRESHOLD);
 376                         g_temp_status = TEMP_POS_10_TO_POS_45;
 377                 }
 378         } else if (BMT_status.temperature >= TEMP_POS_0_THRESHOLD) {
 379                 if ((g_temp_status == TEMP_NEG_10_TO_POS_0 || g_temp_status == TEMP_BELOW_NEG_10)
 380                     && (BMT_status.temperature <= TEMP_POS_0_THRES_PLUS_X_DEGREE)) {
 381                         if (g_temp_status == TEMP_NEG_10_TO_POS_0) {
 382                                 battery_xlog_printk(BAT_LOG_CRTI,
 383                                                     "[BATTERY] Battery Temperature between %d and %d !!\n\r",
 384                                                     TEMP_POS_0_THRES_PLUS_X_DEGREE,
 385                                                     TEMP_POS_10_THRESHOLD);
 386                         }
 387                         if (g_temp_status == TEMP_BELOW_NEG_10) {
 388                                 battery_xlog_printk(BAT_LOG_CRTI,
 389                                                     "[BATTERY] Battery Temperature between %d and %d,not allow charging yet!!\n\r",
 390                                                     TEMP_POS_0_THRESHOLD,
 391                                                     TEMP_POS_0_THRES_PLUS_X_DEGREE);
 392                                 return PMU_STATUS_FAIL;
 393                         }
 394                 } else {
 395                         battery_xlog_printk(BAT_LOG_CRTI,
 396                                             "[BATTERY] Battery Temperature between %d and %d !!\n\r",
 397                                             TEMP_POS_0_THRESHOLD, TEMP_POS_10_THRESHOLD);
 398
 399                         g_temp_status = TEMP_POS_0_TO_POS_10;
 400                 }
 401         } else if (BMT_status.temperature >= TEMP_NEG_10_THRESHOLD) {
 402                 if ((g_temp_status == TEMP_BELOW_NEG_10)
 403                     && (BMT_status.temperature <= TEMP_NEG_10_THRES_PLUS_X_DEGREE)) {
 404                         battery_xlog_printk(BAT_LOG_CRTI,
 405                                             "[BATTERY] Battery Temperature between %d and %d,not allow charging yet!!\n\r",
 406                                             TEMP_NEG_10_THRESHOLD, TEMP_NEG_10_THRES_PLUS_X_DEGREE);
 407
 408                         return PMU_STATUS_FAIL;
 409                 } else {
 410                         battery_xlog_printk(BAT_LOG_CRTI,
 411                                             "[BATTERY] Battery Temperature between %d and %d !!\n\r",
 412                                             TEMP_NEG_10_THRESHOLD, TEMP_POS_0_THRESHOLD);
 413
 414                         g_temp_status = TEMP_NEG_10_TO_POS_0;
 415                 }
 416         } else {
 417                 battery_xlog_printk(BAT_LOG_CRTI,
 418                                     "[BATTERY] Battery below low Temperature(%d) !!\n\r",
 419                                     TEMP_NEG_10_THRESHOLD);
 420                 g_temp_status = TEMP_BELOW_NEG_10;
 421
 422                 return PMU_STATUS_FAIL;
 423         }
 424
 425         /* set CV after temperature changed */
 426
 427         cv_voltage = select_jeita_cv();
 428         battery_charging_control(CHARGING_CMD_SET_CV_VOLTAGE, &cv_voltage);
 429
 430         return PMU_STATUS_OK;
 431 }
 432
 433
 434 static void set_jeita_charging_current(void)
 435 {
 436 #ifdef CONFIG_USB_IF
 437         if (BMT_status.charger_type == STANDARD_HOST)
 438                 return;
 439 #endif
 440
 441         if (g_temp_status == TEMP_NEG_10_TO_POS_0) {
 442                 g_temp_CC_value = CHARGE_CURRENT_350_00_MA;
 443                 g_temp_input_CC_value = CHARGE_CURRENT_500_00_MA;
 444                 battery_xlog_printk(BAT_LOG_CRTI, "[BATTERY] JEITA set charging current : %d\r\n",
 445                                     g_temp_CC_value);
 446         }
 447 }
 448
 449 #endif
 450
 451 bool get_usb_current_unlimited(void)
 452 {
 453         if (BMT_status.charger_type == STANDARD_HOST || BMT_status.charger_type == CHARGING_HOST)
 454                 return usb_unlimited;
 455         else
 456                 return false;
 457 }
 458
 459 void set_usb_current_unlimited(bool enable)
 460 {
 461         usb_unlimited = enable;
 462 }
 463
 464 void select_charging_curret_bcct(void)
 465 {
 466         if ((BMT_status.charger_type == STANDARD_HOST) ||
 467             (BMT_status.charger_type == NONSTANDARD_CHARGER)) {
 468                 if (g_bcct_value < 100)
 469                         g_temp_input_CC_value = CHARGE_CURRENT_0_00_MA;
 470                 else if (g_bcct_value < 500)
 471                         g_temp_input_CC_value = CHARGE_CURRENT_100_00_MA;
 472                 else if (g_bcct_value < 800)
 473                         g_temp_input_CC_value = CHARGE_CURRENT_500_00_MA;
 474                 else if (g_bcct_value == 800)
 475                         g_temp_input_CC_value = CHARGE_CURRENT_800_00_MA;
 476                 else
 477                         g_temp_input_CC_value = CHARGE_CURRENT_500_00_MA;
 478         } else if ((BMT_status.charger_type == STANDARD_CHARGER) ||
 479                    (BMT_status.charger_type == CHARGING_HOST)) {
 480                 g_temp_input_CC_value = CHARGE_CURRENT_MAX;
 481
 482                 /* --------------------------------------------------- */
 483                 /* set IOCHARGE */
 484                 if (g_bcct_value < 550)
 485                         g_temp_CC_value = CHARGE_CURRENT_0_00_MA;
 486                 else if (g_bcct_value < 650)
 487                         g_temp_CC_value = CHARGE_CURRENT_550_00_MA;
 488                 else if (g_bcct_value < 750)
 489                         g_temp_CC_value = CHARGE_CURRENT_650_00_MA;
 490                 else if (g_bcct_value < 850)
 491                         g_temp_CC_value = CHARGE_CURRENT_750_00_MA;
 492                 else if (g_bcct_value < 950)
 493                         g_temp_CC_value = CHARGE_CURRENT_850_00_MA;
 494                 else if (g_bcct_value < 1050)
 495                         g_temp_CC_value = CHARGE_CURRENT_950_00_MA;
 496                 else if (g_bcct_value < 1150)
 497                         g_temp_CC_value = CHARGE_CURRENT_1050_00_MA;
 498                 else if (g_bcct_value < 1250)
 499                         g_temp_CC_value = CHARGE_CURRENT_1150_00_MA;
 500                 else if (g_bcct_value == 1250)
 501                         g_temp_CC_value = CHARGE_CURRENT_1250_00_MA;
 502                 else
 503                         g_temp_CC_value = CHARGE_CURRENT_650_00_MA;
 504                 /* --------------------------------------------------- */
 505
 506         } else {
 507                 g_temp_input_CC_value = CHARGE_CURRENT_500_00_MA;
 508         }
 509 }
 510
 511 static void pchr_turn_on_charging(void);
 512 kal_uint32 set_bat_charging_current_limit(int current_limit)
 513 {
 514         battery_xlog_printk(BAT_LOG_CRTI, "[BATTERY] set_bat_charging_current_limit (%d)\r\n",
 515                             current_limit);
 516
 517         if (current_limit != -1) {
 518                 g_bcct_flag = 1;
 519                 g_bcct_value = current_limit;
 520
 521                 if (current_limit < 70)
 522                         g_temp_CC_value = CHARGE_CURRENT_0_00_MA;
 523                 else if (current_limit < 200)
 524                         g_temp_CC_value = CHARGE_CURRENT_70_00_MA;
 525                 else if (current_limit < 300)
 526                         g_temp_CC_value = CHARGE_CURRENT_200_00_MA;
 527                 else if (current_limit < 400)
 528                         g_temp_CC_value = CHARGE_CURRENT_300_00_MA;
 529                 else if (current_limit < 450)
 530                         g_temp_CC_value = CHARGE_CURRENT_400_00_MA;
 531                 else if (current_limit < 550)
 532                         g_temp_CC_value = CHARGE_CURRENT_450_00_MA;
 533                 else if (current_limit < 650)
 534                         g_temp_CC_value = CHARGE_CURRENT_550_00_MA;
 535                 else if (current_limit < 700)
 536                         g_temp_CC_value = CHARGE_CURRENT_650_00_MA;
 537                 else if (current_limit < 800)
 538                         g_temp_CC_value = CHARGE_CURRENT_700_00_MA;
 539                 else if (current_limit < 900)
 540                         g_temp_CC_value = CHARGE_CURRENT_800_00_MA;
 541                 else if (current_limit < 1000)
 542                         g_temp_CC_value = CHARGE_CURRENT_900_00_MA;
 543                 else if (current_limit < 1100)
 544                         g_temp_CC_value = CHARGE_CURRENT_1000_00_MA;
 545                 else if (current_limit < 1200)
 546                         g_temp_CC_value = CHARGE_CURRENT_1100_00_MA;
 547                 else if (current_limit < 1300)
 548                         g_temp_CC_value = CHARGE_CURRENT_1200_00_MA;
 549                 else if (current_limit < 1400)
 550                         g_temp_CC_value = CHARGE_CURRENT_1300_00_MA;
 551                 else if (current_limit < 1500)
 552                         g_temp_CC_value = CHARGE_CURRENT_1400_00_MA;
 553                 else if (current_limit < 1600)
 554                         g_temp_CC_value = CHARGE_CURRENT_1500_00_MA;
 555                 else if (current_limit == 1600)
 556                         g_temp_CC_value = CHARGE_CURRENT_1600_00_MA;
 557                 else
 558                         g_temp_CC_value = CHARGE_CURRENT_450_00_MA;
 559         } else {
 560                 /* change to default current setting */
 561                 g_bcct_flag = 0;
 562         }
 563
 564         /* wake_up_bat(); */
 565         pchr_turn_on_charging();
 566
 567         return g_bcct_flag;
 568 }
 569
 570
 571 void select_charging_curret(void)
 572 {
 573         if (g_ftm_battery_flag) {
 574                 battery_xlog_printk(BAT_LOG_CRTI, "[BATTERY] FTM charging : %d\r\n",
 575                                     charging_level_data[0]);
 576                 g_temp_CC_value = charging_level_data[0];
 577
 578                 if (g_temp_CC_value == CHARGE_CURRENT_450_00_MA) {
 579                         g_temp_input_CC_value = CHARGE_CURRENT_500_00_MA;
 580                 } else {
 581                         g_temp_input_CC_value = CHARGE_CURRENT_MAX;
 582                         g_temp_CC_value = AC_CHARGER_CURRENT;
 583
 584                         battery_xlog_printk(BAT_LOG_CRTI, "[BATTERY] set_ac_current \r\n");
 585                 }
 586         } else {
 587                 if (BMT_status.charger_type == STANDARD_HOST) {
 588 #ifdef CONFIG_USB_IF
 589                         {
 590                                 g_temp_input_CC_value = CHARGE_CURRENT_MAX;
 591                                 if (g_usb_state == USB_SUSPEND) {
 592                                         g_temp_CC_value = USB_CHARGER_CURRENT_SUSPEND;
 593                                 } else if (g_usb_state == USB_UNCONFIGURED) {
 594                                         g_temp_CC_value = USB_CHARGER_CURRENT_UNCONFIGURED;
 595                                 } else if (g_usb_state == USB_CONFIGURED) {
 596                                         g_temp_CC_value = USB_CHARGER_CURRENT_CONFIGURED;
 597                                 } else {
 598                                         g_temp_CC_value = USB_CHARGER_CURRENT_UNCONFIGURED;
 599                                 }
 600
 601                                 battery_xlog_printk(BAT_LOG_CRTI,
 602                                                     "[BATTERY] STANDARD_HOST CC mode charging : %d on %d state\r\n",
 603                                                     g_temp_CC_value, g_usb_state);
 604                         }
 605 #else
 606                         {
 607                                 g_temp_input_CC_value = USB_CHARGER_CURRENT;
 608                                 g_temp_CC_value = USB_CHARGER_CURRENT;
 609                         }
 610 #endif
 611                 } else if (BMT_status.charger_type == NONSTANDARD_CHARGER) {
 612                         g_temp_input_CC_value = NON_STD_AC_CHARGER_CURRENT;
 613                         g_temp_CC_value = NON_STD_AC_CHARGER_CURRENT;
 614
 615                 } else if (BMT_status.charger_type == STANDARD_CHARGER) {
 616                         g_temp_input_CC_value = AC_CHARGER_CURRENT;
 617                         g_temp_CC_value = AC_CHARGER_CURRENT;
 618 #if defined(CONFIG_MTK_PUMP_EXPRESS_PLUS_SUPPORT)
 619                         if(is_ta_connect == KAL_TRUE)
 620                                 set_ta_charging_current();
 621 #endif
 622                 } else if (BMT_status.charger_type == CHARGING_HOST) {
 623                         g_temp_input_CC_value = CHARGING_HOST_CHARGER_CURRENT;
 624                         g_temp_CC_value = CHARGING_HOST_CHARGER_CURRENT;
 625                 } else if (BMT_status.charger_type == APPLE_2_1A_CHARGER) {
 626                         g_temp_input_CC_value = APPLE_2_1A_CHARGER_CURRENT;
 627                         g_temp_CC_value = APPLE_2_1A_CHARGER_CURRENT;
 628                 } else if (BMT_status.charger_type == APPLE_1_0A_CHARGER) {
 629                         g_temp_input_CC_value = APPLE_1_0A_CHARGER_CURRENT;
 630                         g_temp_CC_value = APPLE_1_0A_CHARGER_CURRENT;
 631                 } else if (BMT_status.charger_type == APPLE_0_5A_CHARGER) {
 632                         g_temp_input_CC_value = APPLE_0_5A_CHARGER_CURRENT;
 633                         g_temp_CC_value = APPLE_0_5A_CHARGER_CURRENT;
 634                 } else {
 635                         g_temp_input_CC_value = CHARGE_CURRENT_500_00_MA;
 636                         g_temp_CC_value = CHARGE_CURRENT_500_00_MA;
 637                 }
 638
 639
 640                 #if defined(CONFIG_MTK_DUAL_INPUT_CHARGER_SUPPORT)
 641                 if (DISO_data.diso_state.cur_vdc_state == DISO_ONLINE) {
 642                         g_temp_input_CC_value = AC_CHARGER_CURRENT;
 643                         g_temp_CC_value = AC_CHARGER_CURRENT;
 644                 }
 645                 #endif
 646
 647 #if defined(CONFIG_MTK_JEITA_STANDARD_SUPPORT)
 648                 set_jeita_charging_current();
 649 #endif
 650         }
 651
 652
 653 }
 654
 655
 656 static kal_uint32 charging_full_check(void)
 657 {
 658         kal_uint32 status;
 659
 660         battery_charging_control(CHARGING_CMD_GET_CHARGING_STATUS, &status);
 661         if (status == KAL_TRUE) {
 662                 g_full_check_count++;
 663                 if (g_full_check_count >= FULL_CHECK_TIMES) {
 664                         return KAL_TRUE;
 665                 } else
 666                         return KAL_FALSE;
 667         } else {
 668                 g_full_check_count = 0;
 669                 return status;
 670         }
 671 }
 672
 673
 674 static void pchr_turn_on_charging(void)
 675 {
 676 #if !defined(CONFIG_MTK_JEITA_STANDARD_SUPPORT)
 677         BATTERY_VOLTAGE_ENUM cv_voltage;
 678 #endif
 679         kal_uint32 charging_enable = KAL_TRUE;
 680
 681         #if defined(CONFIG_MTK_DUAL_INPUT_CHARGER_SUPPORT)
 682         if(KAL_TRUE == BMT_status.charger_exist)
 683                 charging_enable = KAL_TRUE;
 684         else
 685                 charging_enable = KAL_FALSE;
 686         #endif
 687
 688         if (BMT_status.bat_charging_state == CHR_ERROR) {
 689                 battery_xlog_printk(BAT_LOG_CRTI, "[BATTERY] Charger Error, turn OFF charging !\n");
 690
 691                 charging_enable = KAL_FALSE;
 692
 693         } else if ((g_platform_boot_mode == META_BOOT) || (g_platform_boot_mode == ADVMETA_BOOT)) {
 694                 battery_xlog_printk(BAT_LOG_CRTI,
 695                                     "[BATTERY] In meta or advanced meta mode, disable charging.\n");
 696                 charging_enable = KAL_FALSE;
 697         } else {
 698                 /*HW initialization */
 699                 battery_charging_control(CHARGING_CMD_INIT, NULL);
 700
 701                 battery_xlog_printk(BAT_LOG_FULL, "charging_hw_init\n");
 702
 703 #if defined(CONFIG_MTK_PUMP_EXPRESS_PLUS_SUPPORT)
 704         battery_pump_express_algorithm_start();
 705 #endif
 706
 707                 /* Set Charging Current */
 708                 if (get_usb_current_unlimited()) {
 709                         g_temp_input_CC_value = AC_CHARGER_CURRENT;
 710                         g_temp_CC_value = AC_CHARGER_CURRENT;
 711                         battery_xlog_printk(BAT_LOG_FULL,
 712                                             "USB_CURRENT_UNLIMITED, use AC_CHARGER_CURRENT\n");
 713                 } else if (g_bcct_flag == 1) {
 714                         select_charging_curret_bcct();
 715
 716                         battery_xlog_printk(BAT_LOG_FULL,
 717                                             "[BATTERY] select_charging_curret_bcct !\n");
 718                 } else {
 719                         select_charging_curret();
 720
 721                         battery_xlog_printk(BAT_LOG_FULL, "[BATTERY] select_charging_curret !\n");
 722                 }
 723                 battery_xlog_printk(BAT_LOG_CRTI,
 724                                     "[BATTERY] Default CC mode charging : %d, input current = %d\r\n",
 725                                     g_temp_CC_value, g_temp_input_CC_value);
 726                 if (g_temp_CC_value == CHARGE_CURRENT_0_00_MA
 727                     || g_temp_input_CC_value == CHARGE_CURRENT_0_00_MA) {
 728
 729                         charging_enable = KAL_FALSE;
 730
 731                         battery_xlog_printk(BAT_LOG_CRTI,
 732                                             "[BATTERY] charging current is set 0mA, turn off charging !\r\n");
 733                 } else {
 734                         battery_charging_control(CHARGING_CMD_SET_INPUT_CURRENT,
 735                                                  &g_temp_input_CC_value);
 736                         battery_charging_control(CHARGING_CMD_SET_CURRENT, &g_temp_CC_value);
 737
 738                         /*Set CV Voltage */
 739 #if !defined(CONFIG_MTK_JEITA_STANDARD_SUPPORT)
 740 #ifdef HIGH_BATTERY_VOLTAGE_SUPPORT
 741                         cv_voltage = BATTERY_VOLT_04_340000_V;
 742 #else
 743                         cv_voltage = BATTERY_VOLT_04_200000_V;
 744 #endif
 745                         battery_charging_control(CHARGING_CMD_SET_CV_VOLTAGE, &cv_voltage);
 746 #endif
 747                 }
 748         }
 749
 750         /* enable/disable charging */
 751         battery_charging_control(CHARGING_CMD_ENABLE, &charging_enable);
 752
 753         battery_xlog_printk(BAT_LOG_FULL, "[BATTERY] pchr_turn_on_charging(), enable =%d !\r\n",
 754                             charging_enable);
 755 }
 756
 757
 758 PMU_STATUS BAT_PreChargeModeAction(void)
 759 {
 760         battery_xlog_printk(BAT_LOG_CRTI, "[BATTERY] Pre-CC mode charge, timer=%d on %d !!\n\r",
 761                             BMT_status.PRE_charging_time, BMT_status.total_charging_time);
 762
 763         BMT_status.PRE_charging_time += BAT_TASK_PERIOD;
 764         BMT_status.CC_charging_time = 0;
 765         BMT_status.TOPOFF_charging_time = 0;
 766         BMT_status.total_charging_time += BAT_TASK_PERIOD;
 767
 768         /*  Enable charger */
 769         pchr_turn_on_charging();
 770
 771         if (BMT_status.UI_SOC == 100) {
 772                 BMT_status.bat_charging_state = CHR_BATFULL;
 773                 BMT_status.bat_full = KAL_TRUE;
 774                 g_charging_full_reset_bat_meter = KAL_TRUE;
 775         } else if (BMT_status.bat_vol > V_PRE2CC_THRES) {
 776                 BMT_status.bat_charging_state = CHR_CC;
 777         }
 778
 779
 780
 781         return PMU_STATUS_OK;
 782 }
 783
 784
 785 PMU_STATUS BAT_ConstantCurrentModeAction(void)
 786 {
 787         battery_xlog_printk(BAT_LOG_FULL, "[BATTERY] CC mode charge, timer=%d on %d !!\n\r",
 788                             BMT_status.CC_charging_time, BMT_status.total_charging_time);
 789
 790         BMT_status.PRE_charging_time = 0;
 791         BMT_status.CC_charging_time += BAT_TASK_PERIOD;
 792         BMT_status.TOPOFF_charging_time = 0;
 793         BMT_status.total_charging_time += BAT_TASK_PERIOD;
 794
 795         /*  Enable charger */
 796         pchr_turn_on_charging();
 797
 798         if (charging_full_check() == KAL_TRUE) {
 799                 BMT_status.bat_charging_state = CHR_BATFULL;
 800                 BMT_status.bat_full = KAL_TRUE;
 801                 g_charging_full_reset_bat_meter = KAL_TRUE;
 802         }
 803
 804         return PMU_STATUS_OK;
 805 }
 806
 807
 808 PMU_STATUS BAT_BatteryFullAction(void)
 809 {
 810         battery_xlog_printk(BAT_LOG_CRTI, "[BATTERY] Battery full !!\n\r");
 811
 812         BMT_status.bat_full = KAL_TRUE;
 813         BMT_status.total_charging_time = 0;
 814         BMT_status.PRE_charging_time = 0;
 815         BMT_status.CC_charging_time = 0;
 816         BMT_status.TOPOFF_charging_time = 0;
 817         BMT_status.POSTFULL_charging_time = 0;
 818         BMT_status.bat_in_recharging_state = KAL_FALSE;
 819
 820         if (charging_full_check() == KAL_FALSE) {
 821                 battery_xlog_printk(BAT_LOG_CRTI, "[BATTERY] Battery Re-charging !!\n\r");
 822
 823                 BMT_status.bat_in_recharging_state = KAL_TRUE;
 824                 BMT_status.bat_charging_state = CHR_CC;
 825                 battery_meter_reset();
 826         }
 827
 828
 829         return PMU_STATUS_OK;
 830 }
 831
 832
 833 PMU_STATUS BAT_BatteryHoldAction(void)
 834 {
 835         kal_uint32 charging_enable;
 836
 837         battery_xlog_printk(BAT_LOG_CRTI, "[BATTERY] Hold mode !!\n\r");
 838
 839         if (BMT_status.bat_vol < TALKING_RECHARGE_VOLTAGE || g_call_state == CALL_IDLE) {
 840                 BMT_status.bat_charging_state = CHR_CC;
 841                 battery_xlog_printk(BAT_LOG_CRTI,
 842                                     "[BATTERY] Exit Hold mode and Enter CC mode !!\n\r");
 843         }
 844
 845         /*  Disable charger */
 846         charging_enable = KAL_FALSE;
 847         battery_charging_control(CHARGING_CMD_ENABLE, &charging_enable);
 848
 849         return PMU_STATUS_OK;
 850 }
 851
 852
 853 PMU_STATUS BAT_BatteryStatusFailAction(void)
 854 {
 855         kal_uint32 charging_enable;
 856
 857         battery_xlog_printk(BAT_LOG_CRTI, "[BATTERY] BAD Battery status... Charging Stop !!\n\r");
 858
 859 #if defined(CONFIG_MTK_JEITA_STANDARD_SUPPORT)
 860         if ((g_temp_status == TEMP_ABOVE_POS_60) || (g_temp_status == TEMP_BELOW_NEG_10)) {
 861                 temp_error_recovery_chr_flag = KAL_FALSE;
 862         }
 863         if ((temp_error_recovery_chr_flag == KAL_FALSE) && (g_temp_status != TEMP_ABOVE_POS_60)
 864             && (g_temp_status != TEMP_BELOW_NEG_10)) {
 865                 temp_error_recovery_chr_flag = KAL_TRUE;
 866                 BMT_status.bat_charging_state = CHR_PRE;
 867         }
 868 #endif
 869
 870         BMT_status.total_charging_time = 0;
 871         BMT_status.PRE_charging_time = 0;
 872         BMT_status.CC_charging_time = 0;
 873         BMT_status.TOPOFF_charging_time = 0;
 874         BMT_status.POSTFULL_charging_time = 0;
 875
 876         /*  Disable charger */
 877         charging_enable = KAL_FALSE;
 878         battery_charging_control(CHARGING_CMD_ENABLE, &charging_enable);
 879
 880         return PMU_STATUS_OK;
 881 }
 882
 883
 884 void mt_battery_charging_algorithm(void)
 885 {
 886         battery_charging_control(CHARGING_CMD_RESET_WATCH_DOG_TIMER, NULL);
 887
 888 #if defined(CONFIG_MTK_PUMP_EXPRESS_PLUS_SUPPORT)
 889         battery_pump_express_charger_check();
 890 #endif
 891         switch (BMT_status.bat_charging_state) {
 892         case CHR_PRE:
 893                 BAT_PreChargeModeAction();
 894                 break;
 895
 896         case CHR_CC:
 897                 BAT_ConstantCurrentModeAction();
 898                 break;
 899
 900         case CHR_BATFULL:
 901                 BAT_BatteryFullAction();
 902                 break;
 903
 904         case CHR_HOLD:
 905                 BAT_BatteryHoldAction();
 906                 break;
 907
 908         case CHR_ERROR:
 909                 BAT_BatteryStatusFailAction();
 910                 break;
 911         }
 912
 913         battery_charging_control(CHARGING_CMD_DUMP_REGISTER, NULL);
 914 }