bspbattdrvr.cpp

Freescale ARM11系列CPU MX31的WINCE 5.0下的BSP

//-----------------------------------------------------------------------------
//
//  Copyright (C) 2006, Motorola Inc. All Rights Reserved
//
//------------------------------------------------------------------------------
//
// Copyright (C) 2006, Freescale Semiconductor, Inc. All Rights Reserved.
// THIS SOURCE CODE, AND ITS USE AND DISTRIBUTION, IS SUBJECT TO THE TERMS
// AND CONDITIONS OF THE APPLICABLE LICENSE AGREEMENT
//
//------------------------------------------------------------------------------

//-----------------------------------------------------------------------------
//
//  File:  bspbattdrvr.cpp
//
//  Provides the implementation for BSP-specific battdrvr support.
//
//-----------------------------------------------------------------------------
#include <windows.h>
#include "csp.h"

#include "pmic_battery.h"
#include "pmic_adc.h"
#include "regs_adc.h"

#include "bspbattdrvr.h"


//-----------------------------------------------------------------------------
// External Functions

//-----------------------------------------------------------------------------
// External Variables


//-----------------------------------------------------------------------------
// Defines

#define BSP_BATTDRVR_DEBUG     FALSE


//-----------------------------------------------------------------------------
// Types


//-----------------------------------------------------------------------------
// Global Variables


//-----------------------------------------------------------------------------
// Local Variables


//-----------------------------------------------------------------------------
// Local Functions

//-----------------------------------------------------------------------------
//
// Function: BSPBattdrvrGetInfo
//
// This function returns the hardware specific battery information
//
// Parameters:
//      pBattInfo
//          [out] pointer to the structure containing the battery information
//
// Returns:
//      TRUE
//
//-----------------------------------------------------------------------------
BOOL BSPBattdrvrGetInfo(PBATT_INFO pBattInfo)
{
    pBattInfo->adc_level = ADC_SAMPLE_MAX_VALUE;
    pBattInfo->adc_batt_max_V = ADC_BATT_MAX_VOLTAGE;
    pBattInfo->adc_batt_min_V = ADC_BATT_MIN_VOLTAGE;
    pBattInfo->adc_batt_max_I = ADC_BATT_MAX_CURRENT;
    pBattInfo->adc_batt_min_I = ADC_BATT_MIN_CURRENT;
    pBattInfo->adc_charger_max_V = ADC_CHARGER_MAX_VOLTAGE;
    pBattInfo->adc_charger_min_V = ADC_CHARGER_MIN_VOLTAGE;
    pBattInfo->adc_charger_max_I = ADC_CHARGER_MAX_CURRENT;
    pBattInfo->adc_charger_min_I = ADC_CHARGER_MIN_CURRENT;
    pBattInfo->charger_V_limit = MC13783_BATTERY_CHRGDET_VOLT_THRESHOLD_HIGH;

    return TRUE;
}



//-----------------------------------------------------------------------------
//
// Function: BSPBattdrvrGetChargingMode
//
// This function returns the whether MC13783 is using the Dual charging mode
//
// Parameters:
//      ChargeMode
//          [out] pointer to the charge mode, TRUE for dual path charge mode, 
//              FALSE for else
//
// Returns:
//      TRUE if success FALSE if else
//
//-----------------------------------------------------------------------------
BOOL BSPBattdrvrGetChargingMode(BOOL *ChargeMode)
{
    PMIC_STATUS status;
    CHARGER_MODE mode;
    
    //later need to call pmic batt interface api to get the mode
    status = PmicBatteryGetChargerMode(&mode);
    if (status != PMIC_SUCCESS)
    {
        ERRORMSG(TRUE, (TEXT("PmicBatteryGetChargerMode failed\r\n")));
        return FALSE;
    }

    if (mode == DUAL_PATH)
        *ChargeMode = TRUE;
    else
        *ChargeMode = FALSE;
    
    return TRUE;
}


//-----------------------------------------------------------------------------
//
// Function: BSPBattdrvrGetSample
//
// This function returns the batt voltage sample
//
// Parameters:
//      psample
//          [out] pointer to the sample value, 
//                  psample[0] = battery voltage;
//                  psample[1] = battery current;
//                  psample[2] = charger voltage;
//                  psample[3] = charger current; 
//
// Returns:
//      TRUE if success FALSE if else
//
//-----------------------------------------------------------------------------
BOOL BSPBattdrvrGetSample(UINT16 *psample)
{
    BOOL ret = TRUE;
    PMIC_STATUS status;
    UINT16  adc_mul_samples[8];         // must reserve 8
    UINT16  adc_i_sample[8];            // reserve eight ...depending on
                                        // the mode you want to use

    DEBUGMSG(BSP_BATTDRVR_DEBUG, (TEXT("+BSPBattdrvrGetSample\r\n")));

    //call PmicADCGetMultipleChannelsSamples to get the battery voltage
    // and charger voltage & current samples
    status = PmicADCGetMultipleChannelsSamples(
        (1<<MC13783_ADC1_ADA_SEL0_BATT)|
        (1<<MC13783_ADC1_ADA_SEL0_CHRGRAW)|
        (1<<MC13783_ADC1_ADA_SEL0_CHRGISNS), adc_mul_samples);
    if (status != PMIC_SUCCESS)
    {
        ERRORMSG(TRUE, (TEXT("PmicADCGetBattSample failed\r\n")));
        ret = FALSE;
    }
  
    //call PmicADCGetHandsetCurrent to get the battery current sample
    if (ret == TRUE)
    {
        status = PmicADCGetHandsetCurrent(ADC_8CHAN_1X, &adc_i_sample[1]);
        if (status != PMIC_SUCCESS)
        {
            ERRORMSG(TRUE, (TEXT("PmicADCGetBattSample failed\r\n")));
            ret = FALSE;
        }
    }

    psample[BattVoltage] = adc_mul_samples[0];
    psample[BattCurrent] = adc_i_sample[1];
    psample[ChargerVoltage] = adc_mul_samples[1];
    psample[ChargerCurrent] = adc_mul_samples[2];

    DEBUGMSG(BSP_BATTDRVR_DEBUG, (TEXT("samples %d %d %d %d\r\n"), 
        psample[BattVoltage], psample[BattCurrent], psample[ChargerVoltage],
        psample[ChargerCurrent]));

    DEBUGMSG(BSP_BATTDRVR_DEBUG, (TEXT("-BSPBattdrvrGetSample\r\n")));

    return ret;
}


//-----------------------------------------------------------------------------
//
// Function: BSPBattdrvrGetParameters
//
// This function returns the battery and charger voltages, the current as well 
// as a flag that indicates if the curren tis charging or discharging
// 
// Parameters:
//      pBatt_V
//          [out] pointer of the battery voltage
//      pCharger_V
//          [out] pointer of the charger voltage
//      fCharge
//          [out] pointer of the flag TRUE for charging FALSE for discharging
//      I
//          [out] pointer of the charging/discharging current
//
// Returns:
//      TRUE if successful, FALSE for else
//
//-----------------------------------------------------------------------------
BOOL BSPBattdrvrGetParameters(DWORD *pBatt_V,
                              DWORD *pCharger_V,
                              BOOL *fCharge,
                              DWORD *I)
{
    BOOL ret = TRUE;
    BOOL    fDualCharge;
    UINT16  samples[TotalChannels];
    UINT16  batt_i_sample;
    UINT16  charger_i_sample;
    LONG batt_I;
    LONG charger_I;
    BATT_INFO    BattInfo;      //batt info structure obtained from bsp layer

    DEBUGMSG(BSP_BATTDRVR_DEBUG, (TEXT("+BSPBattdrvrGetParameters\r\n")));
    
    //Get Info from BSP layer
    if(BSPBattdrvrGetInfo(&BattInfo) != TRUE)
    { 
        ERRORMSG(TRUE, (TEXT("BSPBattdrvrGetInfo fail !!\r\n")));
        ret = FALSE;
    }   
    
    if (ret == TRUE)
    {
        //check whether the dual charging mode is used
        if (BSPBattdrvrGetChargingMode(&fDualCharge) != TRUE)
        { 
            ERRORMSG(TRUE, (TEXT("Get battery charge mode fail !!\r\n")));
            ret = FALSE; 
        }
    }

    if (ret == TRUE)
    {
        //check whether charger is available -- using the threshold voltage 
        //from pmic spec
        if(BSPBattdrvrGetSample(samples) != TRUE)
        { 
            ERRORMSG(TRUE, (TEXT("Get battery sample fail !!\r\n")));
            ret = FALSE; 
        }
    }


    // determine the battery voltage according to the corresponding ADC sample
    *pBatt_V = 
        BattInfo.adc_batt_min_V +
        (DWORD)((BattInfo.adc_batt_max_V-BattInfo.adc_batt_min_V) *
        samples[BattVoltage]/BattInfo.adc_level);  
    DEBUGMSG(BSP_BATTDRVR_DEBUG, (TEXT("batt_V = %d sample = %d\r\n"),
             *pBatt_V, samples[BattVoltage]));  


    // determine the battery current according to the corresponding ADC sample
    batt_i_sample = samples[BattCurrent];
    if (batt_i_sample & 0x200)
    {
        //perform the 2's complementary conversion
        batt_i_sample = batt_i_sample -1;
        batt_i_sample = ~batt_i_sample;
        batt_i_sample &= 0x1FF;
        batt_I = 
            (-1)*(LONG)(BattInfo.adc_batt_min_I +
            (DWORD)((BattInfo.adc_batt_max_I-BattInfo.adc_batt_min_I) *
            batt_i_sample/BattInfo.adc_level));
    }
    else
    {
        batt_I = 
            (LONG)(BattInfo.adc_batt_min_I +
            (DWORD)((BattInfo.adc_batt_max_I-BattInfo.adc_batt_min_I) *
            batt_i_sample/BattInfo.adc_level));
    }
    DEBUGMSG(BSP_BATTDRVR_DEBUG, (TEXT("batt_I = %d sample = %d\r\n"),
             batt_I, batt_i_sample));   

    
    // determine the charger voltage according to the corresponding ADC sample
    *pCharger_V = 
        BattInfo.adc_charger_min_V +
        (DWORD)((BattInfo.adc_charger_max_V-BattInfo.adc_charger_min_V) *
        samples[ChargerVoltage]/BattInfo.adc_level);    
    DEBUGMSG(BSP_BATTDRVR_DEBUG, (TEXT("charger_V = %d sample = %d\r\n"),
            *pCharger_V, samples[ChargerVoltage]));   

    // determine the charger current according to the corresponding ADC sample
    charger_i_sample = samples[ChargerCurrent];
    if (charger_i_sample & 0x200)
    {
        //perform the 2's complementary conversion
        charger_i_sample = charger_i_sample -1;
        charger_i_sample = ~charger_i_sample;
        charger_i_sample &= 0x1FF;
        charger_I = 
            (-1)*(LONG)(BattInfo.adc_charger_min_I +
            (LONG)((BattInfo.adc_charger_max_I-BattInfo.adc_charger_min_I) *
            charger_i_sample/BattInfo.adc_level));
    }
    else
    {
        charger_I = 
            (LONG)(BattInfo.adc_charger_min_I +
            (LONG)((BattInfo.adc_charger_max_I-BattInfo.adc_charger_min_I) *
            charger_i_sample/BattInfo.adc_level));
    }
    DEBUGMSG(BSP_BATTDRVR_DEBUG, (TEXT("charger_I = %d sample = %d\r\n"), 
             charger_I, charger_i_sample));    


    //according to the charging mode, determine the current to used in the
    //capacity calculating
    if (fDualCharge)
    {
        DEBUGMSG(BSP_BATTDRVR_DEBUG, (TEXT("Dual Charging Mode!\r\n")));  
        if (charger_I < 0)
        {
            *fCharge = FALSE;
            //discharging current equals to the current flowing out of battery
            // in dual charge mode
            *I = abs(batt_I);
            DEBUGMSG(BSP_BATTDRVR_DEBUG,(TEXT("discharging_I = %d \r\n"), *I));
        }
        else
        {
            *fCharge = TRUE;
            //charging current equals to the difference between the charger 
            //current and the battery current in dual charge mode
            *I = abs(charger_I);
            DEBUGMSG(BSP_BATTDRVR_DEBUG, (TEXT("charging_I = %d \r\n"), *I)); 
        } 
    }
    else
    {
        DEBUGMSG(BSP_BATTDRVR_DEBUG, (TEXT("Other Charging Modes!\r\n")));  
        if (batt_I > 0)
        {
            *fCharge = FALSE;
            //discharging current equals to the current flowing out of battery 
            //in other charge modes
            *I = abs(batt_I);
            DEBUGMSG(BSP_BATTDRVR_DEBUG,(TEXT("discharging_I = %d \r\n"), *I));  
        }
        else
        {
            *fCharge = TRUE;
            //charging current equals to the current flowing into battery in
            //other charge modes
            *I = abs(batt_I);
            DEBUGMSG(BSP_BATTDRVR_DEBUG, (TEXT("charging_I = %d \r\n"), *I)); 
        }
    }
    DEBUGMSG(BSP_BATTDRVR_DEBUG, (TEXT("-BSPBattdrvrGetParameters\r\n")));
    return ret;
}