tlg1100api.c

泰景的模拟电视全部驱动及MTK平台界面代码

/*****************************************************************************
* TLG_GetCbCrOrder
*
*
*
*
*****************************************************************************/
TLGDLL_API int TLG_GetCbCrOrder(uint32 base_addr, uint16 *val) {
    uint16 videoConfig3;

    TLG_NULLPTR_CHECK(val);

    TLG_ReadReg(base_addr, REG_0070, &videoConfig3);
    TLGHAL_GET(*val, videoConfig3, REG_0070_BIT2_SHIFT,
            REG_0070_BIT2_MASK);

    return(TLG_ERR_SUCCESS);
}


/*****************************************************************************
* TLG_SetCbCrOrder
*
*
*
*
*****************************************************************************/
TLGDLL_API int TLG_SetCbCrOrder(uint32 base_addr, uint16 val) {
    uint16 videoConfig3;

    TLG_BOUNDS_CHECK(val, TLG_CBCR_SWAP);

    TLG_ReadReg(base_addr, REG_0070, &videoConfig3);
    TLGHAL_SET(videoConfig3, val, REG_0070_BIT2_SHIFT,
            REG_0070_BIT2_MASK);
    TLG_WriteReg(base_addr, REG_0070, videoConfig3);
    return(TLG_ERR_SUCCESS);
}

/*****************************************************************************
* TLG_GetAudioChan
*
*
*
*
*****************************************************************************/
TLGDLL_API int TLG_GetAudioChan(uint32 base_addr, uint16 *val) {
    uint16 soundDsmDac;

    TLG_NULLPTR_CHECK(val);

    TLG_ReadReg(base_addr, REG_0097, &soundDsmDac);
    TLGHAL_GET(*val, soundDsmDac, REG_0097_BIT1_SHIFT,
                REG_0097_BIT1_MASK);
    return(TLG_ERR_SUCCESS);
}


/*****************************************************************************
* TLG_SetAudioChan
*
*
* DAC MODE ONLY
*
*****************************************************************************/
TLGDLL_API int TLG_SetAudioChan(uint32 base_addr, uint16 val) {
    uint16 soundDsmDac;

    TLG_BOUNDS_CHECK(val, TLG_LEFT_RIGHT);

    TLG_ReadReg(base_addr, REG_0097, &soundDsmDac);
    TLGHAL_SET(soundDsmDac, val, REG_0097_BIT1_SHIFT,
                REG_0097_BIT1_MASK);
    TLG_WriteReg(base_addr, REG_0097, soundDsmDac);
    return(TLG_ERR_SUCCESS);
}

/*****************************************************************************
* TLG_GetAudioEnable
*
*
*
*
*****************************************************************************/
TLGDLL_API int TLG_GetAudioEnable(uint32 base_addr, uint16 *val)
{
    uint16 soundDemod1;

    TLG_NULLPTR_CHECK(val);

    TLG_ReadReg(base_addr, REG_008B, &soundDemod1);

    TLGHAL_GET(*val, soundDemod1, REG_008B_BIT0_SHIFT,
                REG_008B_BIT0_MASK);

    return(TLG_ERR_SUCCESS);
}


/*****************************************************************************
* TLG_SetAudioEnable
*
*
*
*
*****************************************************************************/
TLGDLL_API int TLG_SetAudioEnable(uint32 base_addr, uint16 val)
{
    uint16 soundDemod1;

    TLG_BOUNDS_CHECK(val, TLG_ENABLE);

    TLG_ReadReg(base_addr, REG_008B, &soundDemod1);
    TLGHAL_CLEAR(soundDemod1, REG_008B_BIT0_MASK);
    TLGHAL_SET(soundDemod1, val, REG_008B_BIT0_SHIFT,
               REG_008B_BIT0_MASK);
    TLG_WriteReg(base_addr, REG_008B, soundDemod1);
    return(TLG_ERR_SUCCESS);
}

/*****************************************************************************
* TLG_GetAudioMode
*
* master   enable    mode
*   0        0       slave
*   0        1       DAC
*   1        0       master
*   1        1       undefined
*
*****************************************************************************/
TLGDLL_API int TLG_GetAudioMode(uint32 base_addr, uint16 *val) {
    uint16 soundDemod1;
    uint16 soundDsmDac;

    TLG_NULLPTR_CHECK(val);

    TLG_ReadReg(base_addr, REG_008B, &soundDemod1);
    TLG_ReadReg(base_addr, REG_0097, &soundDsmDac);

    /*** Decode according to logic table above */
    if (soundDemod1 & REG_008B_BIT3_MASK)
        if (soundDsmDac & REG_0097_BIT0_MASK) /* never! */
            *val = TLG_UNDEFINED;
        else
            *val = TLG_MASTER;
    else
        if (soundDsmDac & REG_0097_BIT0_MASK)
            *val = TLG_DAC;
        else
            *val = TLG_SLAVE;
    if (*val == TLG_UNDEFINED)
        return(TLG_ERR_FAIL);

    return(TLG_ERR_SUCCESS);
}


/*****************************************************************************
* TLG_SetAudioMode
*
*
*
*
*****************************************************************************/
TLGDLL_API int TLG_SetAudioMode(uint32 base_addr, uint16 val) {
    uint16 soundDemod1;
    uint16 soundDsmDac;

    TLG_BOUNDS_CHECK(val, TLG_DAC);

    TLG_ReadReg(base_addr, REG_008B, &soundDemod1);
    TLG_ReadReg(base_addr, REG_0097, &soundDsmDac);
    switch (val)
    {
        case TLG_MASTER:
        TLGHAL_SET(soundDemod1, 1, REG_008B_BIT3_SHIFT,
                   REG_008B_BIT3_MASK);
        TLGHAL_CLEAR(soundDsmDac, REG_0097_BIT0_MASK);
        break;

        case TLG_SLAVE:
        TLGHAL_CLEAR(soundDsmDac, REG_0097_BIT0_MASK);
        TLGHAL_CLEAR(soundDemod1, REG_008B_BIT3_MASK);
        break;

        case TLG_DAC:
        TLGHAL_CLEAR(soundDemod1, REG_008B_BIT3_MASK);
        TLGHAL_SET(soundDsmDac, 1, REG_0097_BIT0_SHIFT,
                    REG_0097_BIT0_MASK);
        break;

        default:
#ifdef TLG_DO_ERROR_CHECKING
        return(TLG_ERR_PARAM);
#else
        break;
#endif /* TLG_DO_ERROR_CHECKING */
    }
    TLG_WriteReg(base_addr, REG_008B, soundDemod1);
    TLG_WriteReg(base_addr, REG_0097, soundDsmDac);

    return(TLG_ERR_SUCCESS);
}

/*****************************************************************************
* TLG_GetAudioGain
*
* For TLG_MASTER/TLG_SLAVE:
*
* gain = 2*pll + aud :for gain=(0..9)
*
* Recommended settings:
* pll	aud	  gain
* 0	    0	  0
* 0	    1	  1
* 0	    2	  2
* 0	    3	  3
* 0	    4	  4
* 0	    5	  5
* 0	    6	  6
* 0	    7	  7
* 1	    6	  8
* 1	    7	  9
*
* Gain on chip is 2^gain (i.e. 1..2048)
*
* for TLG_DAC:
*
* gain = 2*pll + (3-aud): for gain=(0..5)
* Recommended settings:
* pll	aud	  gain
* 0	    3	  0
* 0	    2	  1
* 0	    1	  2
* 0	    0	  3
* 1	    1	  4
* 1	    0	  5
*****************************************************************************/
TLGDLL_API int TLG_GetAudioGain(uint32 base_addr, uint16 aud_mode, uint16 *gain) {
    uint16 soundDemod2;
    uint16 dsmDac;
    uint16 pll, aud;

    TLG_NULLPTR_CHECK(gain);
    TLG_ReadReg(base_addr, REG_008C, &soundDemod2);
    TLGHAL_GET(pll, soundDemod2, REG_008C_BIT7_SHIFT,
               REG_008C_BIT7_MASK);
    switch (aud_mode)
    {
    case TLG_MASTER:
    case TLG_SLAVE:
            TLGHAL_GET(aud, soundDemod2, REG_008C_BIT6_4_SHIFT,
                        REG_008C_BIT6_4_MASK);
            break;
    case TLG_DAC:
            TLG_ReadReg(base_addr, REG_0097, &dsmDac);
            TLGHAL_GET(aud, dsmDac, REG_0097_BIT5_4_SHIFT,
                        REG_0097_BIT5_4_MASK);
            aud = 3 - aud;
            break;
    default:
            return TLG_ERR_PARAM;
    }

    *gain = 2*pll + aud; /* formula according to TLGHAL specs. */

    return(TLG_ERR_SUCCESS);
}

/*****************************************************************************
* TLG_SetAudioGain
*
*
*
*
*****************************************************************************/
TLGDLL_API int TLG_SetAudioGain(uint32 base_addr, uint16 aud_mode, uint16 gain) {
    uint16 soundDemod2;
    uint16 dsmDac;
    uint16 pll, aud, max_gain=0;


    switch (aud_mode)
    {
    case TLG_MASTER:
    case TLG_SLAVE:
                max_gain = TLG_MAX_AUD_GAIN_DIG;
            break;
    case TLG_DAC:
                max_gain = TLG_MAX_AUD_GAIN_DAC;
            break;
    default:
            return TLG_ERR_PARAM;
    }
    TLG_BOUNDS_CHECK(gain, max_gain);

    /* calculate the proper internal gain settings according to table above  */
    if (gain > (max_gain-2))
    {
        pll = 1;
        aud = gain - 2;
    } else {
        pll = 0;
        aud = gain;
    }
    /* update register(s)                                                    */
    TLG_ReadReg(base_addr, REG_008C, &soundDemod2);
    TLGHAL_SET(soundDemod2, pll, REG_008C_BIT7_SHIFT,
               REG_008C_BIT7_MASK);
    switch (aud_mode)
    {
    case TLG_MASTER:
    case TLG_SLAVE:
            TLGHAL_SET(soundDemod2, aud, REG_008C_BIT6_4_SHIFT,
                        REG_008C_BIT6_4_MASK);
            break;
    case TLG_DAC:
            TLG_ReadReg(base_addr, REG_0097, &dsmDac);
            TLGHAL_SET(dsmDac, (3-aud), REG_0097_BIT5_4_SHIFT,
                        REG_0097_BIT5_4_MASK);
            TLG_WriteReg(base_addr, REG_0097, dsmDac);
            break;
    default:
            return TLG_ERR_PARAM;
    }
    TLG_WriteReg(base_addr, REG_008C, soundDemod2);

    return(TLG_ERR_SUCCESS);
}

/*****************************************************************************
* TLG_GetAudioOutput
*
* master   enable    mode
*   0        0       slave
*   0        1       DAC
*   1        0       master
*   1        1       undefined
*
* For TLG_MASTER/TLG_SLAVE:
*
* gain = 2*pll + aud :for gain=(0..9)
*
* Recommended settings:
* pll	aud	  gain
* 0	    0	  0
* 0	    1	  1
* 0	    2	  2
* 0	    3	  3
* 0	    4	  4
* 0	    5	  5
* 0	    6	  6
* 0	    7	  7
* 1	    6	  8
* 1	    7	  9
*
* Gain on chip is 2^gain (i.e. 1..2048)
*
* for TLG_DAC:
*
* gain = 2*pll + (3-aud): for gain=(0..5)
* Recommended settings:
* pll	aud	  gain
* 0	    3	  0
* 0	    2	  1
* 0	    1	  2
* 0	    0	  3
* 1	    1	  4
* 1	    0	  5
*****************************************************************************/
TLGDLL_API int TLG_GetAudioOutput(uint32 base_addr, uint16 *aud_mode, uint16 *gain) {
    uint16 regData1;
    uint16 regData2;
	uint16 pll, aud;

    TLG_NULLPTR_CHECK(aud_mode);
	TLG_NULLPTR_CHECK(gain);

    TLG_ReadReg(base_addr, REG_008B, &regData1);
    TLG_ReadReg(base_addr, REG_0097, &regData2);

    /*** Decode according to logic table above */
    if (regData1 & REG_008B_BIT3_MASK)
        if (regData2 & REG_0097_BIT0_MASK) /* never! */
            *aud_mode = TLG_UNDEFINED;
        else
            *aud_mode = TLG_MASTER;
    else
        if (regData2 & REG_0097_BIT0_MASK)
            *aud_mode = TLG_DAC;
        else
            *aud_mode = TLG_SLAVE;
    if (*aud_mode == TLG_UNDEFINED)
        return(TLG_ERR_FAIL);
		
    TLG_ReadReg(base_addr, REG_008C, &regData1);
    TLGHAL_GET(pll, regData1, REG_008C_BIT7_SHIFT, REG_008C_BIT7_MASK);
    
	switch (*aud_mode)
    {
    case TLG_MASTER:
    case TLG_SLAVE:
            TLGHAL_GET(aud, regData1, REG_008C_BIT6_4_SHIFT,
                        REG_008C_BIT6_4_MASK);
            break;
    case TLG_DAC:
            TLG_ReadReg(base_addr, REG_0097, &regData2);
            TLGHAL_GET(aud, regData2, REG_0097_BIT5_4_SHIFT,
                        REG_0097_BIT5_4_MASK);
            aud = 3 - aud;
            break;
    default:
            return TLG_ERR_PARAM;
    }

    *gain = 2*pll + aud; /* formula according to TLGHAL specs. */

    return(TLG_ERR_SUCCESS);
}

/*****************************************************************************
* TLG_SetAudioOutput
*