tlg1100api.c

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

*
*
*
*****************************************************************************/
TLGDLL_API int TLG_SetAudioOutput(uint32 base_addr, uint16 aud_mode, uint16 gain) {
    uint16 regData1;
    uint16 regData2;
    uint16 pll, aud, max_gain=0;

    TLG_BOUNDS_CHECK(aud_mode, TLG_DAC);
	TLG_BOUNDS_CHECK(gain, max_gain);

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

    switch (aud_mode)
    {
        case TLG_MASTER:
        TLGHAL_SET(regData1, 1, REG_008B_BIT3_SHIFT, REG_008B_BIT3_MASK);
        TLGHAL_CLEAR(regData2, REG_0097_BIT0_MASK);
		max_gain = TLG_MAX_AUD_GAIN_DIG;
        break;

        case TLG_SLAVE:
        TLGHAL_CLEAR(regData2, REG_0097_BIT0_MASK);
        TLGHAL_CLEAR(regData1, REG_008B_BIT3_MASK);
		max_gain = TLG_MAX_AUD_GAIN_DIG;
        break;

        case TLG_DAC:
        TLGHAL_CLEAR(regData1, REG_008B_BIT3_MASK);
        TLGHAL_SET(regData2, 1, REG_0097_BIT0_SHIFT, REG_0097_BIT0_MASK);
		max_gain = TLG_MAX_AUD_GAIN_DAC;
        break;

        default:
#ifdef TLG_DO_ERROR_CHECKING
        return(TLG_ERR_PARAM);
#else
        break;
#endif /* TLG_DO_ERROR_CHECKING */
    }

    TLG_WriteReg(base_addr, REG_008B, regData1);
    TLG_WriteReg(base_addr, REG_0097, regData2);    

    /* 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, &regData1);
    TLGHAL_SET(regData1, pll, REG_008C_BIT7_SHIFT, REG_008C_BIT7_MASK);

    switch (aud_mode)
	{
    case TLG_MASTER:
    case TLG_SLAVE:
            TLGHAL_SET(regData1, aud, REG_008C_BIT6_4_SHIFT,
                        REG_008C_BIT6_4_MASK);
            break;
    case TLG_DAC:
            TLG_ReadReg(base_addr, REG_0097, &regData2);
            TLGHAL_SET(regData2, (3-aud), REG_0097_BIT5_4_SHIFT,
                        REG_0097_BIT5_4_MASK);
            TLG_WriteReg(base_addr, REG_0097, regData2);
            break;
    default:
            return TLG_ERR_PARAM;
    }
    TLG_WriteReg(base_addr, REG_008C, regData1);

    return(TLG_ERR_SUCCESS);
}

/*****************************************************************************
* TLG_GetI2SAudioData
*
*
*
*
*****************************************************************************/
TLGDLL_API int TLG_GetI2SAudioData(uint32 base_addr, uint16 *R) {
    uint16 regData;

    TLG_NULLPTR_CHECK(R);

    TLG_ReadReg(base_addr, REG_008E, &regData);
    TLGHAL_GET(*R, regData, REG_008E_BIT7_0_SHIFT,
               REG_008E_BIT7_0_MASK);
	if (*R == 0) *R = 256;
    return(TLG_ERR_SUCCESS);
}


/*****************************************************************************
* TLG_SetI2SAudioData
*
*
*
*
*****************************************************************************/
TLGDLL_API int TLG_SetI2SAudioData(uint32 base_addr, uint16 R) {
    uint16 regData;

    TLG_BOUNDS_CHECK(R, 256);
	
	if (R == 256) R = 0;

    TLG_ReadReg(base_addr, REG_008E, &regData);
    TLGHAL_SET(regData, R, REG_008E_BIT7_0_SHIFT,
               REG_008E_BIT7_0_MASK);
    TLG_WriteReg(base_addr, REG_008E, regData);

    return(TLG_ERR_SUCCESS);
}

/*****************************************************************************
* TLG_GetI2SMasterAudioClock
*
*
*
*
*****************************************************************************/
TLGDLL_API int TLG_GetI2SMasterAudioClock(uint32 base_addr, uint16 *M, uint16 *S) {
    uint16 regData;

    TLG_NULLPTR_CHECK(M);
	TLG_NULLPTR_CHECK(S);
	
    TLG_ReadReg(base_addr, REG_0096, &regData);
    TLGHAL_GET(*M, regData, REG_0096_BIT12_8_SHIFT, REG_0096_BIT12_8_MASK);
	TLGHAL_GET(*S, regData, REG_0096_BIT5_0_SHIFT, REG_0096_BIT5_0_MASK);
	
	if (*M == 0) *M = 32;
	if (*S == 0) *S = 64;

    return(TLG_ERR_SUCCESS);
}


/*****************************************************************************
* TLG_SetI2SMasterAudioClock
*
*
*
*
*****************************************************************************/
TLGDLL_API int TLG_SetI2SMasterAudioClock(uint32 base_addr, uint16 M, uint16 S) {
    uint16 regData;

    TLG_BOUNDS_CHECK(M, 32);
	TLG_BOUNDS_CHECK(S, 64);
	
	if (M == 32) M = 0;
	if (S == 64) S = 0;

    TLG_ReadReg(base_addr, REG_0096, &regData);
    TLGHAL_SET(regData, M, REG_0096_BIT12_8_SHIFT, REG_0096_BIT12_8_MASK);
	TLGHAL_SET(regData, S, REG_0096_BIT5_0_SHIFT, REG_0096_BIT5_0_MASK);
    TLG_WriteReg(base_addr, REG_0096, regData);

    return(TLG_ERR_SUCCESS);
}

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

    TLG_NULLPTR_CHECK(val);

    TLG_ReadReg(base_addr, REG_008B, &soundDemod1);
    TLGHAL_GET(*val, soundDemod1, REG_008B_BIT1_SHIFT,
               REG_008B_BIT1_MASK);

    return(TLG_ERR_SUCCESS);
}


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

    TLG_BOUNDS_CHECK(val, TLG_ON);

    TLG_ReadReg(base_addr, REG_008B, &soundDemod1);
    TLGHAL_SET(soundDemod1, val, REG_008B_BIT1_SHIFT,
               REG_008B_BIT1_MASK);
    TLGHAL_SET(soundDemod1, val, REG_008B_BIT8_SHIFT,
                REG_008B_BIT8_MASK);
    TLG_WriteReg(base_addr, REG_008B, soundDemod1);

    return(TLG_ERR_SUCCESS);
}

/*****************************************************************************
* TLG_GetI2SDebugWaveform
*
*
*
*
*****************************************************************************/
TLGDLL_API int TLG_GetI2SDebugWaveform(uint32 base_addr, uint16 *val) {
    uint16 regData;

    TLG_NULLPTR_CHECK(val);

    TLG_ReadReg(base_addr, REG_0095, &regData);
    TLGHAL_GET(*val, regData, REG_0095_BIT0_SHIFT,
               REG_0095_BIT0_MASK);

    return(TLG_ERR_SUCCESS);
}


/*****************************************************************************
* TLG_SetI2SDebugWaveform
*
*
*
*
*****************************************************************************/
TLGDLL_API int TLG_SetI2SDebugWaveform(uint32 base_addr, uint16 val) {
    uint16 regData;

    TLG_BOUNDS_CHECK(val, TLG_ON);

    TLG_ReadReg(base_addr, REG_0095, &regData);
    TLGHAL_SET(regData, val, REG_0095_BIT0_SHIFT,
               REG_0095_BIT0_MASK);
    TLGHAL_SET(regData, 85, REG_0095_BIT7_1_SHIFT,
               REG_0095_BIT7_1_MASK);
    TLG_WriteReg(base_addr, REG_0095, regData);

    return(TLG_ERR_SUCCESS);
}

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

    TLG_NULLPTR_CHECK(val);

    TLG_ReadReg(base_addr, REG_008B, &soundDemod1);
    TLGHAL_GET(*val, soundDemod1, REG_008B_BIT5_4_SHIFT,
               REG_008B_BIT5_4_MASK);
    return(TLG_ERR_SUCCESS);
}


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

    TLG_BOUNDS_CHECK(val, TLG_8KHZ);

    TLG_ReadReg(base_addr, REG_008B, &soundDemod1);
    TLGHAL_SET(soundDemod1, val, REG_008B_BIT5_4_SHIFT,
               REG_008B_BIT5_4_MASK);
    TLG_WriteReg(base_addr, REG_008B, soundDemod1);
    return(TLG_ERR_SUCCESS);
}


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

    TLG_NULLPTR_CHECK(val);

    TLG_ReadReg(base_addr, REG_008B, &soundDemod1);
    TLGHAL_GET(*val, soundDemod1, REG_008B_BIT7_6_SHIFT,
               REG_008B_BIT7_6_MASK);
    return(TLG_ERR_SUCCESS);
}


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

    TLG_BOUNDS_CHECK(val, TLG_8KHZ);

    TLG_ReadReg(base_addr, REG_008B, &soundDemod1);
    TLGHAL_SET(soundDemod1, val, REG_008B_BIT7_6_SHIFT,
               REG_008B_BIT7_6_MASK);
    TLG_WriteReg(base_addr, REG_008B, soundDemod1);

    return(TLG_ERR_SUCCESS);
}

/*****************************************************************************
* TLG_GetExtHSync
*
*
*
*
*****************************************************************************/
TLGDLL_API int TLG_GetExtHSync(uint32 base_addr,
                    uint16 *assert_start,        uint16 *assert_end,
                    uint16 *deassert1_start,     uint16 *deassert1_end,
                    uint16 *deassert2_start,     uint16 *deassert2_end) {

    TLG_NULLPTR_CHECK(assert_start);
    TLG_NULLPTR_CHECK(assert_end);
    TLG_NULLPTR_CHECK(deassert1_start);
    TLG_NULLPTR_CHECK(deassert1_end);
    TLG_NULLPTR_CHECK(deassert2_start);
    TLG_NULLPTR_CHECK(deassert2_end);

    TLG_ReadReg(base_addr, REG_007F, assert_start);
    TLG_ReadReg(base_addr, REG_0080, assert_end);
    TLG_ReadReg(base_addr, REG_0081, deassert1_start);
    TLG_ReadReg(base_addr, REG_0082, deassert1_end);
    TLG_ReadReg(base_addr, REG_0083, deassert2_start);
    TLG_ReadReg(base_addr, REG_0084, deassert2_end);

    return(TLG_ERR_SUCCESS);
}

/*****************************************************************************
* TLG_SetExtHSync
*
*
*
*
*****************************************************************************/
TLGDLL_API int TLG_SetExtHSync(uint32 base_addr,
                    uint16 assert_start,        uint16 assert_end,
                    uint16 deassert1_start,     uint16 deassert1_end,
                    uint16 deassert2_start,     uint16 deassert2_end) {

    TLG_WriteReg(base_addr, REG_007F, assert_start);
    TLG_WriteReg(base_addr, REG_0080, assert_end);
    TLG_WriteReg(base_addr, REG_0081, deassert1_start);
    TLG_WriteReg(base_addr, REG_0082, deassert1_end);
    TLG_WriteReg(base_addr, REG_0083, deassert2_start);
    TLG_WriteReg(base_addr, REG_0084, deassert2_end);
    return(TLG_ERR_SUCCESS);
}

/*****************************************************************************
* TLG_GetExtVSync
*
*
*
*
*****************************************************************************/
TLGDLL_API int TLG_GetExtVSync(uint32 base_addr,
                    uint16 *assert1_start,       uint16 *assert1_end,
                    uint16 *assert2_start,       uint16 *assert2_end,
                    uint16 *assert3_start,       uint16 *assert3_end) {
    TLG_NULLPTR_CHECK(assert1_start);
    TLG_NULLPTR_CHECK(assert1_end);
    TLG_NULLPTR_CHECK(assert2_start);
    TLG_NULLPTR_CHECK(assert2_end);
    TLG_NULLPTR_CHECK(assert3_start);
    TLG_NULLPTR_CHECK(assert3_end);

    TLG_ReadReg(base_addr, REG_0085, assert1_start);
    TLG_ReadReg(base_addr, REG_0086, assert1_end);
    TLG_ReadReg(base_addr, REG_0087, assert2_start);
    TLG_ReadReg(base_addr, REG_0088, assert2_end);
    TLG_ReadReg(base_addr, REG_0089, assert3_start);
    TLG_ReadReg(base_addr, REG_008A, assert3_end);
    return(TLG_ERR_SUCCESS);
}

/*****************************************************************************
* TLG_SetExtVSync
*
*
*
*
*****************************************************************************/
TLGDLL_API int TLG_SetExtVSync(uint32 base_addr,
                    uint16 assert1_start,       uint16 assert1_end,
                    uint16 assert2_start,       uint16 assert2_end,
                    uint16 assert3_start,       uint16 assert3_end) {

    TLG_WriteReg(base_addr, REG_0085, assert1_start);