pmicpdk.cpp

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

           // ignore ADTRIG input
           CSP_BITFVAL(MC13783_ADC1_ADTRIGIGN, MC13783_ADC1_ADTRIGIGN_IGNORE);

    switch (mode)
    {
        // Set RAND = 0, i.e. read 8 channels, 1 time sample
        case ADC_8CHAN_1X: // RAND = 0
            data |= CSP_BITFVAL(MC13783_ADC1_RAND, MC13783_ADC1_RAND_8CHAN_1X);
            break;

        // Set RAND = 1, i.e. read 1 channel, 8 times sample
        case ADC_1CHAN_8X: // RAND = 1
            data |= CSP_BITFVAL(MC13783_ADC1_RAND, MC13783_ADC1_RAND_1CHAN_8X);
            break;
    }
    mask = MC13783_ADC_REGISTER_MASK_ALL;

    SetRegister(addr, data, mask);

    addr = MC13783_ADC0_ADDR;
    data = CSP_BITFVAL(MC13783_ADC0_ADINC1, MC13783_ADC0_ADINC_NO_INCR) |
           CSP_BITFVAL(MC13783_ADC0_ADINC2, MC13783_ADC0_ADINC_NO_INCR) |
           CSP_BITFVAL(MC13783_ADC0_BATICON, MC13783_ADC0_ENABLE);
    mask = CSP_BITFMASK(MC13783_ADC0_ADINC1) |
           CSP_BITFMASK(MC13783_ADC0_ADINC2) |
           CSP_BITFMASK(MC13783_ADC0_BATICON);

    SetRegister(addr, data, mask);


    // Request ADC conversion
    if (PmicADCConvert() != PMIC_SUCCESS)
    {
        ERRORMSG(1, (_T("PmicADCConvert failed!\r\n")));
        goto cleanUp;
    }

    // When in this mode, we only return one value (BATTISNS)
    if (mode == ADC_8CHAN_1X)
    {
        // Set reading channel to ADA
        addr = MC13783_ADC1_ADDR;
        data = CSP_BITFVAL(MC13783_ADC1_ASC, MC13783_ADC1_ASC_ADC_IDLE) |
               CSP_BITFVAL(MC13783_ADC1_ADA1, MC13783_ADC1_ADA_SEL0_BATTISNS);
        mask = CSP_BITFMASK(MC13783_ADC1_ADA1) |
               CSP_BITFMASK(MC13783_ADC1_ASC);

        SetRegister(addr, data, mask);

        // Read channel data
        addr = MC13783_ADC2_ADDR;
        GetRegister(addr, &data);

        *pData = CSP_BITFEXT(data, MC13783_ADC2_ADD1);
        DEBUGMSG(ZONE_FUNC, (_T("data = %d\r\n"), *pData));
    }
    else
    {   // else... read eight values at a time
        // ADA0=BATTP; ADA1=BATTP-BATTI; ADA2=BATTP; ADA3=BATTP-BATTI; 
        // ADA4=BATTP; ADA5=BATTP-BATTI; ADA6=BATTP; ADA7=BATTP-BATTI.
        PmicReadEightValues(pData);
    }

    // Disable the ADC
    PmicADCDisable();
    rc = TRUE;

cleanUp:

    LeaveCriticalSection(&adcCs);
    DEBUGMSG(ZONE_FUNC, (TEXT("-%s()\r\n"), __WFUNCTION__));

    return rc;
}


//-----------------------------------------------------------------------------
//
// Function: PmicIoctlADCGetMultipleChannelsSamples
//
// This function gets one sample for multiple channels.    
//
// Parameters:
//      channels
//          [in] selected  channels (up to 16 channels). 
//
//      dwLenIn
//          [in] Unused.
//
//      pBufOut
//          [out] pointer to  the sampled values (up to 16 sampled values).
//               The returned results will be ordered according to the channel
//               selected.
//      dwLenOut
//          [out] Unused.
//
// Returns:
//      TRUE if the successful, FALSE otherwise.
//
//-----------------------------------------------------------------------------
BOOL PmicIoctlADCGetMultipleChannelsSamples(PBYTE pBufIn, DWORD dwLenIn, 
                                        PBYTE pBufOut, DWORD dwLenOut)
{
    BOOL rc = FALSE;
    UINT32 addr[3], data[3], mask[3];
    UINT32 temp, tmp_addr;
    UINT8 i, j;
    UINT16 channels = *((UINT16*)pBufIn);
    UINT16* pData = (UINT16*) pBufOut;
    UINT8 low_index = 0, high_index = 0;
    UINT16 tmp[2][8];

    // Grab critical section, ADC can only handle one set of
    // conversions at a time
    EnterCriticalSection(&adcCs);

    DEBUGMSG(ZONE_FUNC, (TEXT("+%s()\r\n"), __WFUNCTION__));

    // Configure ADC for the specified channels conversion. We used 8 channel 
    // and 1 time sample mode, and placed the A/D data in result register 1 
    // and 2. 
    //

    // If some channels in the group 0, other channels are in the group1,
    // we have to do two ADC conversions.
       
    // Group 0 when AD_SEL1 = 0
    if ((channels & CSP_BITFMASK(MC13783_ADC_BATT)) |
        (channels & CSP_BITFMASK(MC13783_ADC_BATTISNS)) |
        (channels & CSP_BITFMASK(MC13783_ADC_BPSNS)) |
        (channels & CSP_BITFMASK(MC13783_ADC_CHRGRAW)) |
        (channels & CSP_BITFMASK(MC13783_ADC_CHRGISNS)) |
        (channels & CSP_BITFMASK(MC13783_ADC_RTHEN)) |
        (channels & CSP_BITFMASK(MC13783_ADC_LICELL)) |
        (channels & CSP_BITFMASK(MC13783_ADC_DTHEN)))
    {
        addr[0] = MC13783_ADC1_ADDR;

                  // enable A/D
        data[0] = CSP_BITFVAL(MC13783_ADC1_ADEN, MC13783_ADC1_ADEN_ENABLE) |
            // set RAND = 0, i.e. read 8 channels, 1 time sample
            CSP_BITFVAL(MC13783_ADC1_RAND, MC13783_ADC1_RAND_8CHAN_1X) |
            // set ATO delay only before first conversion
            CSP_BITFVAL(MC13783_ADC1_ATOX, MC13783_ADC1_ATOX_DELAY_FIRST) |                    
            CSP_BITFVAL(MC13783_ADC1_AD_SEL, MC13783_ADC1_AD_SEL_GROUP0) |
            CSP_BITFVAL(MC13783_ADC1_ATO, MC13783_ADC_DEFAULT_ATO_SETTING) |
            // ignore ADTRIG input
            CSP_BITFVAL(MC13783_ADC1_ADTRIGIGN, MC13783_ADC1_ADTRIGIGN_IGNORE) |
            // we will use auto ADINC1
            CSP_BITFVAL(MC13783_ADC1_ADA1, MC13783_ADC1_ADA_SEL0_BATT) |
            // we will use auto ADINC2
            CSP_BITFVAL(MC13783_ADC1_ADA2, MC13783_ADC1_ADA_SEL0_CHRGISNS);

        mask[0] =  MC13783_ADC_REGISTER_MASK_ALL;

        high_index = 1;
    }
    else
    {
        low_index = 1;
    }
        
    // Group 1 when AD_SEL1 = 1
    if ((channels & CSP_BITFMASK(MC13783_ADC_ADIN8)) |
        (channels & CSP_BITFMASK(MC13783_ADC_ADIN9)) |
        (channels & CSP_BITFMASK(MC13783_ADC_ADIN10)) |
        (channels & CSP_BITFMASK(MC13783_ADC_ADIN11)) |
        (channels & CSP_BITFMASK(MC13783_ADC_TSX1)) |
        (channels & CSP_BITFMASK(MC13783_ADC_TSX2)) |
        (channels & CSP_BITFMASK(MC13783_ADC_TSY1)) |
        (channels & CSP_BITFMASK(MC13783_ADC_TSY2)))
    {       
        addr[1] = MC13783_ADC1_ADDR;
                  // enable A/D  
        data[1] = CSP_BITFVAL(MC13783_ADC1_ADEN, MC13783_ADC1_ADEN_ENABLE) |
            // set RAND = 1, i.e. read 8 channels, 1 time sample
            CSP_BITFVAL(MC13783_ADC1_RAND, MC13783_ADC1_RAND_8CHAN_1X) |
            // set ATO delay only before first conversion
            CSP_BITFVAL(MC13783_ADC1_ATOX, MC13783_ADC1_ATOX_DELAY_FIRST) |    
            CSP_BITFVAL(MC13783_ADC1_AD_SEL, MC13783_ADC1_AD_SEL_GROUP1) |
            CSP_BITFVAL(MC13783_ADC1_ATO, MC13783_ADC_DEFAULT_ATO_SETTING) |
            // ignore ADTRIG input
            CSP_BITFVAL(MC13783_ADC1_ADTRIGIGN, MC13783_ADC1_ADTRIGIGN_IGNORE) |
            CSP_BITFVAL(MC13783_ADC1_ADA1, MC13783_ADC1_ADA_SEL1_ADIN8) |
            CSP_BITFVAL(MC13783_ADC1_ADA2, MC13783_ADC1_ADA_SEL1_TSX1);

        mask[1] =  MC13783_ADC_REGISTER_MASK_ALL;

        high_index = 2;
    }
                
    if (high_index <= low_index)
    {
        ERRORMSG(1,
         (_T("PmicIoctlADCGetMultipleChannelsSamples Invalid Parameter!\r\n")));
        goto cleanUp;
    }
        
    // We select 8 channels and 1 times sample. Set automatic increment mode
    addr[2] = MC13783_ADC0_ADDR;

    data[2] = CSP_BITFVAL(MC13783_ADC0_ADINC1, MC13783_ADC0_ADINC_AUTO_INCR) |
              CSP_BITFVAL(MC13783_ADC0_ADINC2, MC13783_ADC0_ADINC_AUTO_INCR) |
              CSP_BITFVAL(MC13783_ADC0_BATICON, MC13783_ADC0_ENABLE) |
              CSP_BITFVAL(MC13783_ADC0_CHRGICON, MC13783_ADC0_ENABLE) |
              CSP_BITFVAL(MC13783_ADC0_RTHEN, MC13783_ADC0_ENABLE) |
              CSP_BITFVAL(MC13783_ADC0_LICELLCON, MC13783_ADC0_ENABLE) |
              CSP_BITFVAL(MC13783_ADC0_DTHEN, MC13783_ADC0_ENABLE);

    mask[2] = CSP_BITFMASK(MC13783_ADC0_ADINC1) |
              CSP_BITFMASK(MC13783_ADC0_ADINC2) |
              CSP_BITFMASK(MC13783_ADC0_BATICON) |
              CSP_BITFMASK(MC13783_ADC0_CHRGICON) |
              CSP_BITFMASK(MC13783_ADC0_RTHEN) |
              CSP_BITFMASK(MC13783_ADC0_DTHEN) |
              CSP_BITFMASK(MC13783_ADC0_LICELLCON);

    SetRegister(addr[2], data[2], mask[2]);

    // Process the ADC for group(s)
    for (i = low_index; i < high_index; i++)
    {
        SetRegister(addr[i], data[i], mask[i]);

        // Request ADC conversion
        if (PmicADCConvert() != PMIC_SUCCESS)
        {
            ERRORMSG(1, (_T("PmicADCConvert failed!\r\n")));
            goto cleanUp;
        }
    
        // One time reading for getting 2 values, total 4 times reading
        tmp_addr = MC13783_ADC2_ADDR;
        for (j = 0; j < 4; j++)
        {
            // Read channel data
            GetRegister(tmp_addr, &temp);

            // Get the ADC values
            tmp[i][j] = CSP_BITFEXT(temp, MC13783_ADC2_ADD1);
            tmp[i][4+j] = CSP_BITFEXT(temp, MC13783_ADC2_ADD2);

        } // End of for loop reading register

    } // End of for loop processing group(s)
        
    // Return the pData's values following channel order like: 
    // BATT, BATTISNS, BPSNS, CHRGRAW, CHRGISNS, RTHEN, LICELL, DTHEN,
    // ADIN8, ADIN9, ADIN10, ADIN11, TSX1, TSX2, TSY1, TSY2

    // In addition, we will only return those values that the caller selects
    // the channel. No more!
    for (i = low_index; i<high_index; i++)
    {
        for (j = 0; j<8; j++)
        {
            if ((channels >> (i*8+j)) & 1)
            {
                *pData++ = tmp[i][j];
                DEBUGMSG(ZONE_FUNC, (_T("data = %d\r\n"), tmp[i][j]));
            }
        }
    }

    // Disable the ADC
    PmicADCDisable();
    rc = TRUE;

cleanUp:

    LeaveCriticalSection(&adcCs);
    DEBUGMSG(ZONE_FUNC, (TEXT("-%s()\r\n"), __WFUNCTION__));

    return rc;
}

//-----------------------------------------------------------------------------
//
// Function: PmicIoctlADCGetSingleChannelSample
//
// This function gets one channel sample. It can be a single sample or multiple
// depending on the bMultipleSampleFlag.
//
// Parameters:
//      pBufIn
//          [in] pointer to the selected channel 
//
//      dwLenIn
//          [in] Unused.
//
//      pBufOut
//         [out] pointer to  the sampled values
//
//      dwLenOut
//          [out] Unused.
//      
//      bMultipleSampleFlag
//          [in] Flag to chose between 1x and 8x samples ... if TRUE then 8x
//
// Returns:
//      TRUE if the successful, FALSE otherwise.
//-----------------------------------------------------------------------------
BOOL 
PmicIoctlADCGetSingleChannelSample(PBYTE pBufIn, DWORD dwLenIn, PBYTE pBufOut,
                                        DWORD dwLenOut, BOOL bMultipleSampleFlag)
{
    BOOL rc = FALSE;
    UINT32 addr, data, mask;
    UINT32 temp = 0;
    UINT32 group = 0;
    UINT32 chann = 0;
    UINT32 ena = 0;
    UINT16 channels = *((UINT16*)pBufIn);
    UINT16* pData = (UINT16*) pBufOut;
       
    // Grab critical section, ADC can only handle one set of conversions at a 
    // time
    EnterCriticalSection(&adcCs);

    DEBUGMSG(ZONE_FUNC, (TEXT("+%s()\r\n"), __WFUNCTION__));

    if (PmicADCGetSettings(channels, &group, &chann, &ena) != PMIC_SUCCESS)
    {
        ERRORMSG(1,
         (_T("PmicIoctlADCGetSingleChannelSample Invalid Parameter!\r\n")));
        goto cleanUp;
    }

    if( bMultipleSampleFlag == TRUE)
        // We used 1 channels and 8 times sample, and placed the A/D data in 
        // result register 1 Set RAND = 1, i.e. read 1 channels, 8 times sample
        data = CSP_BITFVAL(MC13783_ADC1_RAND, MC13783_ADC1_RAND_1CHAN_8X) |
               group | chann;
    else
        // We used 8 channel and 1 time sample, and placed the A/D data in 
        // result register 1. Set RAND = 0, i.e. read 8 channels, 1 time sample
        data = CSP_BITFVAL(MC13783_ADC1_RAND, MC13783_ADC1_RAND_8CHAN_1X) |
               group;

    // enable A/D set ATO delay only before first conversion, and ignore ADTRIG
    //input
    addr = MC13783_ADC1_ADDR;
    data |= CSP_BITFVAL(MC13783_ADC1_ADEN, MC13783_ADC1_ADEN_ENABLE) |
            CSP_BITFVAL(MC13783_ADC1_ATOX, MC13783_ADC1_ATOX_DELAY_FIRST) |
            CSP_BITFVAL(MC13783_ADC1_ATO, MC13783_ADC_DEFAULT_ATO_SETTING) |
            CSP_BITFVAL(MC13783_ADC1_ADTRIGIGN, MC13783_ADC1_ADTRIGIGN_IGNORE);
    mask = MC13783_ADC_REGISTER_MASK_ALL;

    SetRegister(addr, data, mask);


    // We read one sample only. So we set non-automatic increment mode.
    addr = MC13783_ADC0_ADDR;
    data = CSP_BITFVAL(MC13783_ADC0_ADINC1, MC13783_ADC0_ADINC_NO_INCR) |
           CSP_BITFVAL(MC13783_ADC0_ADINC2, MC13783_ADC0_ADINC_NO_INCR) |
           ena;
    mask = CSP_BITFMASK(MC13783_ADC0_ADINC1) |
           CSP_BITFMASK(MC13783_ADC0_ADINC2) |
           CSP_BITFMASK(MC13783_ADC0_BATICON) |
           CSP_BITFMASK(MC13783_ADC0_CHRGICON) |
           CSP_BITFMASK(MC13783_ADC0_RTHEN) |
           CSP_BITFMASK(MC13783_ADC0_DTHEN) |
           CSP_BITFMASK(MC13783_ADC0_LICELLCON);

    SetRegister(addr, data, mask);

    // Request ADC conversion
    if (PmicADCConvert() != PMIC_SUCCESS)
    {
        ERRORMSG(1, (_T("PmicADCConvert failed!\r\n")));
        goto cleanUp;
    }
    
    if( bMultipleSampleFlag == TRUE)
    {
        // read out the eight values and place in area pointed to by pData
        PmicReadEightValues(pData);
    }
    else
    {
        // read out one channel, set reading channel to ADA
        addr = MC13783_ADC1_ADDR;
        data = CSP_BITFVAL(MC13783_ADC1_ASC, MC13783_ADC1_ASC_ADC_IDLE) |chann;
        mask = CSP_BITFMASK(MC13783_ADC1_ADA1) |
               CSP_BITFMASK(MC13783_ADC1_ASC);

        SetRegister(addr, data, mask);

        // Re