bspbattdrvr.cpp

freescale i.mx31 BSP CE5.0全部源码

    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)); 
        }
    }

    if ((*pBatt_V <= BattInfo.adc_batt_min_V) && (*fCharge))
        *fCharge = FALSE;
    if (*pCharger_V < BattInfo.charger_V_limit)
        *fCharge = FALSE;

    DEBUGMSG(BSP_BATTDRVR_DEBUG, (TEXT("-BSPBattdrvrGetParameters\r\n")));
    return ret;
}

//-----------------------------------------------------------------------------
//
// Function: BSPBattdrvrSetCharger
//
// This function set the charger voltage and current limit
// 
// Parameters:
//      voltage
//          [in] charging voltage limit
//            level 0 = 4.05V
//            1 = 4.10V
//            2 = 4.15V
//            3 = 4.20V
//            4 = 4.25V
//            5 = 4.30V
//            6 = 3.80V ... lowest setting
//            7 = 4.50V     
//      current
//          [in] charging current limit
//            level 0 = 0 mA    (max value)
//            1 = 100 mA  (max value)
//              ...       (in increment of 100 mA)
//           13 = 1300 mA (max value)
//           14 = 1800 mA (max value)
//           15 = disables the current limit
//          
//
// Returns:
//      TRUE if successful, FALSE for else
//
//-----------------------------------------------------------------------------
BOOL BSPBattdrvrSetCharger(UINT8 voltage,
                              UINT8 current)
                    
{
    PMIC_STATUS status;
    BOOL bSuspendEnable = FALSE;
     
    if (current > MAX_SAFE_CURRENT_LEVEL)  
    {
        ERRORMSG(TRUE, (TEXT("BSPBattdrvrSetCharger fail, the current set = %d is so large\r\n"), current));
        return FALSE;
    }

    if ((voltage > MAX_SAFE_VOLTAGE_LEVEL) && (voltage != MIN_VOLTAGE_LEVEL))  
    {
        ERRORMSG(TRUE, (TEXT("BSPBattdrvrSetCharger fail, the voltage set = %d is so large\r\n"), voltage));
        return FALSE;
    }
    
    status = PmicBatterSetCharger(BATT_MAIN_CHGR, voltage, current);  
    if (status != PMIC_SUCCESS)
    {
        ERRORMSG(TRUE, (TEXT("PmicBatterSetCharger failed, voltage = %d, current = %d\r\n"), voltage, current));
        return FALSE;
    }

    KernelIoControl(IOCTL_HAL_ENABLE_SUSPEND, &bSuspendEnable, 
        sizeof(bSuspendEnable), NULL, 0, NULL);

    PmicBatterLedControl(TRUE);
    
    return TRUE;
   
}

BOOL BSPBattdrvrSetTrickleCurrent(UINT8 current)
{
    if (PmicBatterySetTrickleCurrent(current) != PMIC_SUCCESS)
    {
        ERRORMSG(TRUE, (TEXT("PmicBatterySetTrickleCurrent failed, current = %d\r\n"), current));
        return FALSE;
    }
    else
        return TRUE;
}


BOOL BSPBattdrvrDisableCharger(void)
{
    PMIC_STATUS status;
    BOOL bSuspendEnable = TRUE;

    status = PmicBatterDisableCharger(BATT_MAIN_CHGR);
    if (status != PMIC_SUCCESS)
    {
        ERRORMSG(TRUE, (TEXT("PmicBatterDisableCharger failed \r\n")));
        return FALSE;
    }

    PmicBatterLedControl(FALSE);
    
    KernelIoControl(IOCTL_HAL_ENABLE_SUSPEND, &bSuspendEnable, 
        sizeof(bSuspendEnable), NULL, 0, NULL);
    return TRUE;
}

static BOOL
BSPBattdrvrChargeDetectThreadProc(LPVOID lpParam)
{ 

    while(1)
    {
        if (WaitForSingleObject(hIntrEventChargeDetect, INFINITE) == WAIT_OBJECT_0)
        {
            WaitForSingleObject(hChargeDetechMutex, INFINITE);
            bChargeDetech = TRUE;
            ReleaseMutex(hChargeDetechMutex);
        }
    }

    ExitThread(TRUE);

    return TRUE;
}


BOOL BSPBattdrvrIsChargeDetect(void)
{
    return bChargeDetech;
}

void BSPBattdrvrClearChargeDetectFlag(void)
{
    WaitForSingleObject(hChargeDetechMutex, INFINITE);
    bChargeDetech = FALSE;
    ReleaseMutex(hChargeDetechMutex);
}

BOOL BSPBattAttach(void)
{
    BOOL rc = FALSE;

    if (PmicInterruptRegister(PMIC_MC13783_INT_CHGDETI, gChargeDetectEventName)
        != PMIC_SUCCESS)
    {
        ERRORMSG(TRUE, (_T("BSPBattAttach:  PmicInterruptRegister failed\r\n")));
        goto cleanUp;
    }
    if (PmicInterruptEnable(PMIC_MC13783_INT_CHGDETI) != PMIC_SUCCESS)
    {
        ERRORMSG(TRUE, (_T("BSPBattAttach:  PmicInterruptEnable failed\r\n")));
        goto cleanUp;
    }

    hChargeDetechMutex = CreateMutex(NULL, FALSE, L"MUTEX_CHARGEDETECH");
 
    hIntrEventChargeDetect = CreateEvent(NULL, FALSE, FALSE, gChargeDetectEventName);

    hChargeDetectThread = CreateThread(NULL, 0,
                                  (LPTHREAD_START_ROUTINE)BSPBattdrvrChargeDetectThreadProc,
                                  0, 0, NULL);

    if (!hChargeDetectThread)
    {
        ERRORMSG(1 ,(TEXT("BSPBattAttach: CreateThread failed\r\n")));
        PmicInterruptDeregister(PMIC_MC13783_INT_CHGDETI);
        goto cleanUp;    
    }

    rc = TRUE;

    return rc;
    
cleanUp:
    if (PmicInterruptDeregister(PMIC_MC13783_INT_CHGDETI) != PMIC_SUCCESS)
    {
        ERRORMSG(TRUE, (_T("BSPBattAttach:  PmicInterruptDeregister failed\r\n")));
    }
     
    return rc;
}