/* Copyright (c) 2015, The Linux Foundation. All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
    * Redistributions of source code must retain the above copyright
      notice, this list of conditions and the following disclaimer.
    * Redistributions in binary form must reproduce the above
      copyright notice, this list of conditions and the following
      disclaimer in the documentation and/or other materials provided
      with the distribution.
    * Neither the name of The Linux Foundation nor the names of its
      contributors may be used to endorse or promote products derived
      from this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

/*===========================================================================

                     INCLUDE FILES

===========================================================================*/
#include "pm_app_smbchg.h"
#include "pm_smbchg_chgr.h"
#include "pm_smbchg_bat_if.h"
#include "pm_app_smbchg.h"
#include "pm_fg_adc_usr.h"
#include "pm_fg_driver.h"
#include "pm_smbchg_driver.h"
#include "pm_comm.h"
#include "pm_smbchg_dc_chgpth.h"
#include <debug.h>
#include <platform/timer.h>
#include <sys/types.h>
#include <target.h>


/*===========================================================================

                     PROTOTYPES

===========================================================================*/


/*===========================================================================

                     GLOBAL TYPE DEFINITIONS

===========================================================================*/
#define  PM_REG_CONFIG_SETTLE_DELAY       175  * 1000 //175ms  ; Delay required for battery voltage de-glitch time
#define  PM_WEAK_BATTERY_CHARGING_DELAY   500 * 1000  //500ms
#define  PM_WIPOWER_START_CHARGING_DELAY  3500 * 1000 //3.5sec
#define  PM_MIN_ADC_READY_DELAY             1 * 1000  //1ms
#define  PM_MAX_ADC_READY_DELAY     2000              //2s
#define SBL_PACKED_SRAM_CONFIG_SIZE 3

#define boot_log_message(...) dprintf(CRITICAL, __VA_ARGS__)

static pm_smbchg_bat_if_low_bat_thresh_type pm_dbc_bootup_volt_threshold;
static bool display_initialized;
static bool charge_in_progress;
char panel_name[256];

pm_err_flag_type pm_smbchg_get_charger_path(uint32 device_index, pm_smbchg_usb_chgpth_pwr_pth_type* charger_path);
pm_err_flag_type pm_appsbl_chg_config_vbat_low_threshold(uint32 device_index, pm_smbchg_specific_data_type *chg_param_ptr);

/*===========================================================================

                     FUNCTION IMPLEMENTATION

===========================================================================*/
pm_err_flag_type pm_appsbl_chg_check_weak_battery_status(uint32 device_index)
{
   pm_err_flag_type err_flag = PM_ERR_FLAG__SUCCESS;
   pm_smbchg_specific_data_type *chg_param_ptr = NULL;
   pm_smbchg_chgr_chgr_status_type vbatt_chging_status;
   boolean hot_bat_hard_lim_rt_sts  = FALSE;
   boolean cold_bat_hard_lim_rt_sts = FALSE;
   boolean vbatt_weak_status = TRUE;
   boolean adc_reading_ready = FALSE;
   boolean bat_present       = TRUE;
   uint32 vbat_adc = 0;
   uint16  wait_index = 0;
   boolean vbatt_status = FALSE;
   pm_smbchg_misc_src_detect_type chgr_src_detected;
   boolean configure_icl_flag = FALSE;
   boolean chg_prog_message_flag = FALSE;
   pm_smbchg_usb_chgpth_pwr_pth_type charger_path = PM_SMBCHG_USB_CHGPTH_PWR_PATH__INVALID;;  uint32  bootup_threshold;

   pm_smbchg_driver_init(device_index);
   pm_fg_driver_init(device_index);

   chg_param_ptr = (pm_smbchg_specific_data_type*)pm_target_information_get_specific_info();
   ASSERT(chg_param_ptr);
   bootup_threshold = chg_param_ptr->bootup_battery_theshold_mv; 

   if(chg_param_ptr->dbc_bootup_volt_threshold.enable_config == PM_ENABLE_CONFIG)
   {
      //Configure Vlowbatt threshold: Used by PMI on next bootup
      err_flag  |= pm_appsbl_chg_config_vbat_low_threshold(device_index, chg_param_ptr); 
   }

   //Check Battery presence
   err_flag |= pm_smbchg_bat_if_get_bat_pres_status(device_index, &bat_present);
   if( bat_present == FALSE )
   {
      dprintf(CRITICAL, "Booting up to HLOS: Charger is Connected and NO battery\n");
      return err_flag;
   }


   //Detect the typpe of charger used
   //err_flag |= pm_smbchg_usb_chgpth_get_pwr_pth(device_index, &
   err_flag |= pm_smbchg_get_charger_path(device_index, &charger_path);
   if (charger_path == PM_SMBCHG_USB_CHGPTH_PWR_PATH__DC_CHARGER) 
   {

      bootup_threshold = chg_param_ptr->wipwr_bootup_battery_theshold_mv;
   }
   else if (charger_path == PM_SMBCHG_USB_CHGPTH_PWR_PATH__USB_CHARGER)
   {
      bootup_threshold = chg_param_ptr->bootup_battery_theshold_mv;
   }

   //Enable BMS FG Algorithm BCL
   err_flag |= pm_fg_adc_usr_enable_bcl_monitoring(device_index, TRUE);
   if ( err_flag != PM_ERR_FLAG__SUCCESS )  
   { 
       return err_flag;
   }


   while( vbatt_weak_status == TRUE )  //While battery is in weak state
   {
      //Check Vbatt ADC level  
      err_flag |= pm_fg_adc_usr_get_bcl_values(device_index, &adc_reading_ready); //Check if Vbatt ADC is ready

      //Check if Vbatt ADC is Ready
      for (wait_index = 0; wait_index < PM_MAX_ADC_READY_DELAY; wait_index++)
      {
        if(adc_reading_ready == FALSE)
        {
           udelay(PM_MIN_ADC_READY_DELAY);
           err_flag |= pm_fg_adc_usr_get_bcl_values(device_index,&adc_reading_ready);
        }
        else
        {
           break;
        }
      }

      if ( err_flag != PM_ERR_FLAG__SUCCESS )  { break;} 

      if ( adc_reading_ready)
      {
         err_flag |= pm_fg_adc_usr_get_calibrated_vbat(device_index, &vbat_adc); //Read calibrated vbatt ADC
         if ( err_flag != PM_ERR_FLAG__SUCCESS )  { break;}

         //Check if ADC reading is within limit
         if ( vbat_adc >=  bootup_threshold)  //Compaire it with SW bootup threshold
         {
            vbatt_weak_status = FALSE;
            break; //bootup
         }
   }
   else
   {
         boot_log_message("ERROR:  ADC Reading is NOT Ready\n");
         err_flag |= PM_ERR_FLAG__ADC_NOT_READY;
         break; 
   }

      //Check if USB charger is SDP
      err_flag |= pm_smbchg_misc_chgr_port_detected(device_index, &chgr_src_detected);
      if (chgr_src_detected == PM_SMBCHG_MISC_SRC_DETECT_SDP) 
   {
         if (configure_icl_flag == FALSE)
         {
            //Check Vlow_batt status
            err_flag |= pm_smbchg_chgr_vbat_sts(device_index, &vbatt_status);
            if (vbatt_status)
            {
               //set ICL to 500mA
               err_flag |= pm_smbchg_usb_chgpth_set_cmd_il(device_index, PM_SMBCHG_USBCHGPTH_CMD_IL__USB51_MODE, TRUE);
               err_flag |= pm_smbchg_usb_chgpth_set_cmd_il(device_index, PM_SMBCHG_USBCHGPTH_CMD_IL__USBIN_MODE_CHG, FALSE);
               configure_icl_flag = TRUE;
            }
         }
   }

      if (chg_prog_message_flag == FALSE)
      {
          //Ensure that Charging is enabled
          err_flag |= pm_smbchg_chgr_enable_src(device_index, FALSE);
          err_flag |= pm_smbchg_chgr_set_chg_polarity_low(device_index, FALSE);
          err_flag |= pm_smbchg_bat_if_config_chg_cmd(device_index, PM_SMBCHG_BAT_IF_CMD__EN_BAT_CHG, TRUE);
          udelay(PM_WEAK_BATTERY_CHARGING_DELAY);
      }

      //Check if JEITA check is enabled
      if (chg_param_ptr->enable_jeita_hard_limit_check == TRUE)
      {
         //Read JEITA condition
         err_flag |= pm_smbchg_bat_if_irq_status(device_index, PM_SMBCHG_BAT_IF_HOT_BAT_HARD_LIM,  PM_IRQ_STATUS_RT, &hot_bat_hard_lim_rt_sts );
         err_flag |= pm_smbchg_bat_if_irq_status(device_index, PM_SMBCHG_BAT_IF_COLD_BAT_HARD_LIM, PM_IRQ_STATUS_RT, &cold_bat_hard_lim_rt_sts);
         if ( err_flag != PM_ERR_FLAG__SUCCESS )  { break;}  

         if ( ( hot_bat_hard_lim_rt_sts  == TRUE ) || (cold_bat_hard_lim_rt_sts == TRUE) )  
         {
            continue;  // Stay in this loop as long as JEITA Hard Hot/Cold limit is exceeded
         }
      }

	if (!charge_in_progress)
      dprintf(INFO,"APPSBL Weak Battery charging: Start\n");

      charge_in_progress = true;
#if DISPLAY_SPLASH_SCREEN
      if (!display_initialized)
         target_display_init(panel_name);
      display_initialized = true;
#endif
      /* Wait for 500 msecs before looking for vbat */
      udelay(PM_WEAK_BATTERY_CHARGING_DELAY); //500ms


      //Check if Charging in progress
      err_flag |= pm_smbchg_chgr_get_chgr_sts(device_index, &vbatt_chging_status);
      if ( err_flag != PM_ERR_FLAG__SUCCESS )  { break;}

      if ( vbatt_chging_status.charging_type == PM_SMBCHG_CHGR_NO_CHARGING )
      {
         if (charger_path == PM_SMBCHG_USB_CHGPTH_PWR_PATH__DC_CHARGER) 
         {
            //Delay for 3.5sec for charging to begin, and check charging status again prior to shutting down.
            udelay(PM_WIPOWER_START_CHARGING_DELAY); //3500ms 

            err_flag |= pm_smbchg_chgr_get_chgr_sts(device_index, &vbatt_chging_status);
            if ( err_flag != PM_ERR_FLAG__SUCCESS )  { break;}

            if ( vbatt_chging_status.charging_type == PM_SMBCHG_CHGR_NO_CHARGING )
            {
               boot_log_message("ERROR: Charging is NOT in progress: Shutting Down\n");
               shutdown_device();
            }
         }
         else
         {
            boot_log_message("ERROR: Charging is NOT in progress: Shutting Down\n");
            shutdown_device();
         }
      }
      else
      {
#ifdef DEBUG_CHARGER
          dprintf(INFO, "APPSBL Charging in Progress....\n");
#endif
          chg_prog_message_flag = TRUE;
      }
   }//while


   if (charger_path == PM_SMBCHG_USB_CHGPTH_PWR_PATH__DC_CHARGER) 
   {
      //If battery is good, Toggle SHDN_N_CLEAR_CMD Reg:  Set 0x1340[6] to  1 and then  0
      err_flag = pm_smbchg_usb_chgpth_set_cmd_il(device_index, PM_SMBCHG_USBCHGPTH_CMD_IL__SHDN_N_CLEAR_CMD, TRUE);
      err_flag = pm_smbchg_usb_chgpth_set_cmd_il(device_index, PM_SMBCHG_USBCHGPTH_CMD_IL__SHDN_N_CLEAR_CMD, FALSE);
   }
   
   if (charge_in_progress)
     dprintf(INFO, "APPSBL Weak Battery Charging: Done \n");

   charge_in_progress = false;
   return err_flag; 
}


pm_err_flag_type pm_smbchg_get_charger_path(uint32 device_index, pm_smbchg_usb_chgpth_pwr_pth_type* charger_path)
{
   pm_err_flag_type err_flag = PM_ERR_FLAG__SUCCESS;
   boolean usbin_uv_status = TRUE;
   boolean usbin_ov_status = TRUE;
   boolean dcbin_uv_status = TRUE;
   boolean dcbin_ov_status = TRUE;

   //DC charger present, if DCIN_UV_RT_STS and DCIN_UV_RT_STS status is 0 (INT_RT_STS : 0x1410[1] and [0] == 0)
   err_flag |= pm_smbchg_dc_chgpth_irq_status(device_index, PM_SMBCHG_DC_CHGPTH_DCBIN_UV, PM_IRQ_STATUS_RT, &dcbin_uv_status);
   err_flag |= pm_smbchg_dc_chgpth_irq_status(device_index, PM_SMBCHG_DC_CHGPTH_DCBIN_OV, PM_IRQ_STATUS_RT, &dcbin_ov_status);
   //USB charger present, if USBIN_UV_RT_STS and USBIN_OV_RT_STS status is 0 ( INT_RT_STS : 0x1310[1] and [0] == 0)
   err_flag |= pm_smbchg_usb_chgpth_irq_status(device_index, PM_SMBCHG_USB_CHGPTH_USBIN_UV, PM_IRQ_STATUS_RT, &usbin_uv_status);
   err_flag |= pm_smbchg_usb_chgpth_irq_status(device_index, PM_SMBCHG_USB_CHGPTH_USBIN_OV, PM_IRQ_STATUS_RT, &usbin_ov_status);

   if((dcbin_uv_status == FALSE) && (dcbin_ov_status == FALSE))
   {
      *charger_path = PM_SMBCHG_USB_CHGPTH_PWR_PATH__DC_CHARGER;
   }
   else if((usbin_uv_status == FALSE) && (usbin_ov_status == FALSE))
   {
      *charger_path = PM_SMBCHG_USB_CHGPTH_PWR_PATH__USB_CHARGER;
   }
   else
   {
      *charger_path = PM_SMBCHG_USB_CHGPTH_PWR_PATH__INVALID;
   }

   return err_flag;
}


pm_err_flag_type pm_appsbl_chg_config_vbat_low_threshold(uint32 device_index, pm_smbchg_specific_data_type *chg_param_ptr)
{
   pm_err_flag_type err_flag = PM_ERR_FLAG__SUCCESS;

   pm_dbc_bootup_volt_threshold = chg_param_ptr->dbc_bootup_volt_threshold.vlowbatt_threshold;

   if (chg_param_ptr->dbc_bootup_volt_threshold.enable_config == PM_ENABLE_CONFIG)
   {
   if (pm_dbc_bootup_volt_threshold  >= PM_SMBCHG_BAT_IF_LOW_BATTERY_THRESH_INVALID)
   {
      err_flag = PM_ERR_FLAG__INVALID_VBATT_INDEXED;
      return err_flag;
   }

      err_flag = pm_smbchg_bat_if_set_low_batt_volt_threshold(device_index, pm_dbc_bootup_volt_threshold);
#ifdef DEBUG_CHARGER
      dprintf(INFO,"Configure Vlowbatt threshold");
#endif
   }

   return err_flag;
}

#ifndef LK
pm_err_flag_type pm_sbl_config_fg_sram(uint32 device_index)
   {
  pm_err_flag_type err_flag = PM_ERR_FLAG__SUCCESS;
  FgSramAddrDataEx_type *sram_data_ptr = NULL;
  FgSramAddrDataEx_type pm_sbl_sram_data[SBL_PACKED_SRAM_CONFIG_SIZE];
  pm_model_type pmic_model = PMIC_IS_INVALID;
  boolean sram_enable_config_flag = FALSE;

  //Check if any SRAM configuration is needed
  sram_data_ptr = (FgSramAddrDataEx_type*)pm_target_information_get_specific_info(PM_PROP_FG_SPECIFIC_DATA);
  CORE_VERIFY_PTR(sram_data_ptr);
  for (int i=0; i< SBL_SRAM_CONFIG_SIZE; i++) 
  {
     sram_enable_config_flag |= sram_data_ptr[i].EnableConfig;
   }

   
  if (sram_enable_config_flag == TRUE )
  {
     pmic_model = pm_get_pmic_model(device_index);   //Check if PMIC exists
     if ( (pmic_model != PMIC_IS_INVALID) || (pmic_model != PMIC_IS_UNKNOWN) )
     {
        //boot_log_message("BEGIN: Configure FG SRAM");

        //Pre-process JEITA data
        pm_sbl_sram_data[0].SramAddr = sram_data_ptr[0].SramAddr;
        pm_sbl_sram_data[0].SramData = (sram_data_ptr[3].SramData  << 24)| 
                                       (sram_data_ptr[2].SramData  << 16)|   
                                       (sram_data_ptr[1].SramData  <<  8)|   
                                        sram_data_ptr[0].SramData;
        pm_sbl_sram_data[0].DataOffset = sram_data_ptr[0].DataOffset;  
        pm_sbl_sram_data[0].DataSize = 4;
        //Set JEITA threshould configuration flag
        pm_sbl_sram_data[0].EnableConfig = sram_data_ptr[0].EnableConfig | sram_data_ptr[1].EnableConfig | 
                                           sram_data_ptr[2].EnableConfig | sram_data_ptr[3].EnableConfig;   

        //Pre-process Thermistor Beta Data
        //thremistor_c1_coeff
        pm_sbl_sram_data[1]  = sram_data_ptr[4];

        //thremistor_c2_coeff and thremistor_c3_coeff
        pm_sbl_sram_data[2].SramAddr   = sram_data_ptr[5].SramAddr;
        pm_sbl_sram_data[2].SramData   = (sram_data_ptr[6].SramData << 16) | sram_data_ptr[5].SramData;
        pm_sbl_sram_data[2].DataOffset = sram_data_ptr[5].DataOffset;  
        pm_sbl_sram_data[2].DataSize = 4;
        pm_sbl_sram_data[2].EnableConfig   = sram_data_ptr[5].EnableConfig;

        //Configure SRAM Data
        err_flag |= PmicFgSram_ProgBurstAccessEx(device_index, pm_sbl_sram_data, SBL_PACKED_SRAM_CONFIG_SIZE);

        //Test: Read Back
        //err_flag |= PmicFgSram_Dump(device_index, 0x0454, 0x0454);
        //err_flag |= PmicFgSram_Dump(device_index, 0x0444, 0x0448);
        //err_flag |= PmicFgSram_Dump(device_index, 0x0448, 0x0452);
        
        //boot_log_message("END: Configure FG SRAM");
     }
  }

   return err_flag; 
}


pm_err_flag_type pm_sbl_config_chg_parameters(uint32 device_index)
{
   pm_err_flag_type err_flag = PM_ERR_FLAG__SUCCESS;
   static pm_smbchg_specific_data_type *chg_param_ptr;
   
   if(chg_param_ptr == NULL)
   {
      chg_param_ptr = (pm_smbchg_specific_data_type*)pm_target_information_get_specific_info(PM_PROP_SMBCHG_SPECIFIC_DATA);
      CORE_VERIFY_PTR(chg_param_ptr);
   }

   //Vlowbatt Threshold  
   //  - Done on:  pm_sbl_chg_config_vbat_low_threshold()
   
   //Charger Path Input Priority 
   if (chg_param_ptr->chgpth_input_priority.enable_config == PM_ENABLE_CONFIG)
   {
      pm_smbchg_chgpth_input_priority_type chgpth_priority = chg_param_ptr->chgpth_input_priority.chgpth_input_priority;
      if (chgpth_priority < PM_SMBCHG_USBCHGPTH_INPUT_PRIORITY_INVALID) 
      {
          err_flag |= pm_smbchg_chgpth_set_input_priority(device_index, chgpth_priority);
      }
      else
      {
         err_flag |= PM_ERR_FLAG__INVALID_PARAMETER;
      }
   }


   //Battery Missing Detection Source 
   if (chg_param_ptr->bat_miss_detect_src.enable_config == PM_ENABLE_CONFIG)
   {
      pm_smbchg_bat_miss_detect_src_type batt_missing_det_src = chg_param_ptr->bat_miss_detect_src.bat_missing_detection_src;
      if (batt_missing_det_src < PM_SMBCHG_BAT_IF_BAT_MISS_DETECT_SRC_INVALID) 
      {
          err_flag |= pm_smbchg_bat_if_set_bat_missing_detection_src(device_index, batt_missing_det_src);
      }
      else
      {
         err_flag |= PM_ERR_FLAG__INVALID_PARAMETER;
      }
   }

   //WDOG Timeout      
   if (chg_param_ptr->wdog_timeout.enable_config == PM_ENABLE_CONFIG)
   {
      pm_smbchg_wdog_timeout_type wdog_timeout = chg_param_ptr->wdog_timeout.wdog_timeout;
      if (wdog_timeout < PM_SMBCHG_MISC_WD_TMOUT_INVALID) 
      {
          err_flag |= pm_smbchg_misc_set_wdog_timeout(device_index, wdog_timeout);
      }
      else
      {
         err_flag |= PM_ERR_FLAG__INVALID_PARAMETER;
      }
   }


   //Enable WDOG                      
   if (chg_param_ptr->enable_wdog.enable_config == PM_ENABLE_CONFIG)
   {
      pm_smbchg_wdog_timeout_type enable_smbchg_wdog = chg_param_ptr->enable_wdog.enable_wdog;
      err_flag |= pm_smbchg_misc_enable_wdog(device_index, enable_smbchg_wdog);
   }


   //FAST Charging Current            
   if (chg_param_ptr->fast_chg_i.enable_config == PM_ENABLE_CONFIG)
   {
      uint32 fast_chg_i_ma = chg_param_ptr->fast_chg_i.fast_chg_i_ma;
      if ((fast_chg_i_ma >= 300) && (fast_chg_i_ma <= 3000) )
      {
          err_flag |= pm_smbchg_chgr_set_fast_chg_i(device_index, fast_chg_i_ma);
      }
      else
      {
         err_flag |= PM_ERR_FLAG__INVALID_PARAMETER;
      }
   }

   //Pre Charge Current               
   if (chg_param_ptr->pre_chg_i.enable_config == PM_ENABLE_CONFIG)
   {
      uint32 pre_chg_i_ma = chg_param_ptr->pre_chg_i.pre_chg_i_ma;
      if ((pre_chg_i_ma >= 100) && (pre_chg_i_ma <= 550) )
      {
          err_flag |= pm_smbchg_chgr_set_pre_chg_i(device_index, pre_chg_i_ma);
      }
      else
      {
         err_flag |= PM_ERR_FLAG__INVALID_PARAMETER;
      }
   }

   //Pre to Fast Charge Current       
   if (chg_param_ptr->pre_to_fast_chg_theshold_mv.enable_config == PM_ENABLE_CONFIG)
   {
      uint32 p2f_chg_mv = chg_param_ptr->pre_to_fast_chg_theshold_mv.pre_to_fast_chg_theshold_mv;
      if ((p2f_chg_mv >= 2400) && (p2f_chg_mv <= 3000)  )
      {
          err_flag |= pm_smbchg_chgr_set_p2f_threshold(device_index, p2f_chg_mv);
      }
      else
      {
         err_flag |= PM_ERR_FLAG__INVALID_PARAMETER;
      }
   }

   //Float Voltage : 3600mV to 4500 mv                   
   if (chg_param_ptr->float_volt_theshold_mv.enable_config == PM_ENABLE_CONFIG)
   {
      uint32 float_volt_mv = chg_param_ptr->float_volt_theshold_mv.float_volt_theshold_mv;
      if ((float_volt_mv >= 3600) && (float_volt_mv <= 4500))
      {
          err_flag |= pm_smbchg_chgr_set_float_volt(device_index, float_volt_mv);
      }
      else
      {
         err_flag |= PM_ERR_FLAG__INVALID_PARAMETER;
      }
   }


   //USBIN Input Current Limit  :Valid value is 300 to 3000mAmp      
   if (chg_param_ptr->usbin_input_current_limit.enable_config == PM_ENABLE_CONFIG)
   {
      uint32 usbin_i_limit_ma = chg_param_ptr->usbin_input_current_limit.usbin_input_current_limit;
      if ((usbin_i_limit_ma >= 300) && (usbin_i_limit_ma <= 3000))
      {
          err_flag |= pm_smbchg_usb_chgpth_set_usbin_current_limit(device_index, usbin_i_limit_ma);
      }
      else
      {
         err_flag |= PM_ERR_FLAG__INVALID_PARAMETER;
      }
   }


   //DCIN Input Current Limit : valid range is 300 to 2000 mAmp         
   if (chg_param_ptr->dcin_input_current_limit.enable_config == PM_ENABLE_CONFIG)
   {
      uint32 dcin_i_limit_ma = chg_param_ptr->dcin_input_current_limit.dcin_input_current_limit;
      if ((dcin_i_limit_ma >= 300) && (dcin_i_limit_ma <= 3200))
      {
          err_flag |= pm_smbchg_dc_chgpth_set_dcin_current_limit(device_index, dcin_i_limit_ma);
      }
      else
      {
         err_flag |= PM_ERR_FLAG__INVALID_PARAMETER;
      }
   }


   return err_flag; 
}
#endif

bool pm_appsbl_charging_in_progress()
{
	return charge_in_progress;
}

bool pm_appsbl_display_init_done()
{
	return display_initialized;
}

pm_err_flag_type pm_appsbl_set_dcin_suspend(uint32_t device_index)
{
	pm_err_flag_type err_flag = PM_ERR_FLAG__SUCCESS;

	err_flag = pm_smbchg_usb_chgpth_set_cmd_il(device_index, PM_SMBCHG_USBCHGPTH_CMD_IL__DCIN_SUSPEND, TRUE);

	return err_flag;
}