lcd_func.c

Realtek 公司的RTD2523A芯片原厂source code,没有被修改过的。

// Set Dclk Frequency in kHz
void Set_DPLL(unsigned long Freq)
{
    unsigned int    M_Code;
    unsigned char   PLL_Div;

    // We want to set DPLL offset to middle(2048), so the target DPLL M/N setting
    // should be 16/15 of target frequency.

    M_Code  = Freq * 8 * USER_MODE_NCODE * 16 / ((unsigned long)RTD_XTAL * 15);

    if (255 < M_Code)
    {
        PLL_Div = 1;                    // Output DPLL for DCLK
        M_Code  = (M_Code + 2) >> 2;     // Round to integer
    }
    else
    {
        PLL_Div = 2;                    // Output DPLL/2 for DCLK
        M_Code  = (M_Code + 1) >> 1;     // Round to integer
    }    

    // Original Formula : M_Code/Ich = 17.6 must be constant
    // Ich   = M_Code * 10 / 176
    // 2*Ich = M_Code * 20 / 176 , set D0[0] to 0, then I = 2 * Ich
    // I     = 2 * Ich = 2.5u + D0[3]*2.5u + D0[4]*5u + D0[5]*10u + D0[6]*20u + D0[7]*30u(A)
    // 2*I   = 4 * Ich = 5u + D0[3]*5u + D0[4]*10u + D0[5]*20u + D0[6]*40u + D0[7]*60u(A)

    // Calculate the 4 * Ich,
    Data[5]     = ((unsigned int)M_Code * 4 * 10 / 176) - 5;
    Data[6]     = 0x00;
    
    if (60 <= Data[5])
    {
        Data[5] -= 60;
        Data[6] |= 0x80; 
    }    
    if (40 <= Data[5])
    {
        Data[5] -= 40;
        Data[6] |= 0x40;
    }    
    if (20 <= Data[5])
    {
        Data[5] -= 20;
        Data[6] |= 0x20;
    }
    if (10 <= Data[5])
    {
        Data[5] -= 10;
        Data[6] |= 0x10;
    }
    if (5 <= Data[5])
    {
        Data[5] -= 5;
        Data[6] |= 0x08;
    }
		
	Data[0] = 7;
    Data[1] = Y_INC;
    Data[2] = DPLL_CTRL_D0;
    Data[3] = Data[6];
    Data[4] = M_Code - 2;

    // Enable SSP and Offset Frequency Direction set to Downward
    Data[5] = ((1 == PLL_Div) ? 0x30 : 0x70) | (USER_MODE_NCODE - 2);
    Data[6] = 0x04;
    Data[7] = 0;
    RTDWrite(Data);  
    
    // DCLK frequency in Hz
    ((unsigned long *)Data)[0]  = (unsigned long)RTD_XTAL * 1000 / (PLL_Div * 2) * M_Code / USER_MODE_NCODE;

    // Offset resolution (DCLK / 2^15) in Hz
    ((unsigned long *)Data)[1]  = ((unsigned long *)Data)[0] >> 15;

    // Target Frequency of DCLK in Hz
    M_Code  = (((unsigned long *)Data)[0] - (Freq * 1000)) / ((unsigned long *)Data)[1];
    M_Code  = M_Code & 0x0fff;

    RTDSetByte(DCLK_OFFSET_LSB_9A, (unsigned char)M_Code);
    RTDSetByte(DCLK_OFFSET_MSB_9B, (unsigned char)((M_Code >> 8) | 0x20));
    //RTDSetBit(DCLK_OFFSET_MSB_9B, 0xf0, (unsigned char)((M_Code >> 8) | 0x20));

    RTDSetBit(FX_LST_LEN_H_5A, 0xff, 0x08); //Enable DDS Spread Spectrum Output Function
}

void Enable_Watch_Dog(unsigned char function)
{
#if (AS_NON_FRAMESYNC || AS_DV_TOTAL || AS_PLL_NONLOCK)

    if (ACTIVE_STATE == ucCurrStatus && bFrameSync)
    {
#if (AS_NON_FRAMESYNC)
        if (function & WATCH_DOG_FRAMESYNC)     RTDSetBit(ODD_CTRL_8E, 0xef, 0x10);
#endif
#if (AS_DV_TOTAL)
        if (function & WATCH_DOG_DVTOTAL)
        {
            RTDSetByte(DV_TOTAL_STATUS_3D, 0x00);
            RTDSetBit(DV_BKGD_STA_31, 0x7f, 0x80);
        }
#endif
#if (AS_PLL_NONLOCK)
        if (function & WATCH_DOG_NONLOCK)
        {
            if (SOURCE_VGA == (stGUD1.INPUT_SOURCE & 0x07))     RTDSetBit(ODD_CTRL_8E, 0xdf, 0x20);
        }
#endif

        RTDSetBit(DV_BKGD_STA_31, 0x9f, 0x60);
    }

#else

    Disable_Watch_Dog(function);

#endif
}

void Disable_Watch_Dog(unsigned char function)
{
#if (AS_NON_FRAMESYNC || AS_DV_TOTAL || AS_PLL_NONLOCK)

    if (function & WATCH_DOG_FRAMESYNC)     RTDSetBit(ODD_CTRL_8E, 0xef, 0x00);

    if (function & WATCH_DOG_DVTOTAL)
    {
        RTDSetByte(DV_TOTAL_STATUS_3D, 0x00);
        RTDSetBit(DV_BKGD_STA_31, 0x7f, 0x00);
    }

    if (function & WATCH_DOG_NONLOCK)       RTDSetBit(ODD_CTRL_8E, 0xdf, 0x00);

#else

    if (function)   RTDSetBit(DV_BKGD_STA_31, 0x9f, 0x00);

#endif

}

void SetVolume()
{
    stGUD3.VOLUME   &= 0x1f;

#if (AUDIO_TYPE == AUDIO_LM4832)
    Data[0] = 10;
    Data[1] = ADDR_LM4832;
    Data[2] = 0x00;
    Data[3] = 0x02;
    Data[4] = 0x00;                     // Input Volume - 0 dB
    Data[5] = 0x26;                     // Bass         - 0 dB
    Data[6] = 0x46;                     // Treble       - 0 dB
    Data[7] = 0x60 | stGUD3.VOLUME;     // Right Volume
    Data[8] = 0x80 | stGUD3.VOLUME;     // Left Volume

    // Mic 1 selected with 20dB when input source is VGA or DVI
    // Both Mic 1 and 2 selected with 20dB when input source is AV or S-Video
    Data[9] = (SOURCE_AV <= (stGUD1.INPUT_SOURCE & 0x07)) ? 0xa6 : 0xa4;
    
    I2CWrite(Data);
#endif

#if (AUDIO_TYPE == AUDIO_PWM2)
    Data[0] = 6;
    Data[1] = Y_INC;
    Data[2] = OSD_ROW_90;
    Data[3] = 0x80;
    Data[4] = 0x01;
#if (INV_VOLUME)
    Data[5] = (0xff -(stGUD3.VOLUME << 3));
#else
	Data[5] = (stGUD3.VOLUME << 3);
#endif
	Data[6] = 0;
    RTDWrite(Data);
#endif


#if (AUDIO_TYPE == AUDIO_PWM0)

    Data[0] = 6;
    Data[1] = Y_INC;
    Data[2] = OSD_ROW_90;
    Data[3] = 0x00;
    Data[4] = 0x01;
#if (INV_VOLUME)
    Data[5] = (0xff -(stGUD3.VOLUME << 3));
#else
	Data[5] = (stGUD3.VOLUME << 3);
#endif
	Data[6] = 0;
    RTDWrite(Data);
#endif
}

///////////////////////////////////////////////////////////////////////////////////////////////

void Save_GUD0(void)
{
    Data[0]     = 11;
    Data[1]     = ADDR_EROM1;
    Data[2]     = 0xE0;
    Data[3]     = stGUD0.CONTRAST;
    Data[4]     = stGUD0.BRIGHT;
    Data[5]     = stGUD0.RTD_R_CONTRAST;
    Data[6]     = stGUD0.RTD_G_CONTRAST;
    Data[7]     = stGUD0.RTD_B_CONTRAST;
    Data[8]     = stGUD0.RTD_R_BRIGHT;
    Data[9]     = stGUD0.RTD_G_BRIGHT;
    Data[10]    = stGUD0.RTD_B_BRIGHT;
    I2CWrite(Data);

    Delay_Xms(SET_2404_DELAY);
}

void Load_GUD0(void)
{
    I2CRead(ADDR_EROM1, 0xE0 , 8);

    stGUD0.CONTRAST         = Data[0];
    stGUD0.BRIGHT           = Data[1];
    stGUD0.RTD_R_CONTRAST   = Data[2];
    stGUD0.RTD_G_CONTRAST   = Data[3];
    stGUD0.RTD_B_CONTRAST   = Data[4];
    stGUD0.RTD_R_BRIGHT     = Data[5];
    stGUD0.RTD_G_BRIGHT     = Data[6];
    stGUD0.RTD_B_BRIGHT     = Data[7];
}

void Save_GUD1(void)
{
    Data[0]     = 9;
    Data[1]     = ADDR_EROM1;
    Data[2]     = 0xE8;
    Data[3]     = stGUD1.FUNCTION;
    Data[4]     = stGUD1.INPUT_SOURCE;
    Data[5]     = stGUD1.FILTER;
    Data[6]     = stGUD1.OSD_POSH;
    Data[7]     = stGUD1.OSD_POSV;
    Data[8]     = stGUD1.OSD_TIMEOUT;
    I2CWrite(Data);

    Delay_Xms(SET_2404_DELAY);
}

void Load_GUD1(void)
{
    I2CRead(ADDR_EROM1, 0xE8 , 6);
    
    stGUD1.FUNCTION         = Data[0];
    stGUD1.INPUT_SOURCE     = Data[1];
    stGUD1.FILTER           = Data[2];
    stGUD1.OSD_POSH         = Data[3];
    stGUD1.OSD_POSV         = Data[4];
    stGUD1.OSD_TIMEOUT      = Data[5];

}

void Save_GUD2(void)
{
    Data[0]     = 9;
    Data[1]     = ADDR_EROM1;
    Data[2]     = 0xF0;
    Data[3]     = stGUD2.AD_R_GAIN;
    Data[4]     = stGUD2.AD_G_GAIN;
    Data[5]     = stGUD2.AD_B_GAIN;
    Data[6]     = stGUD2.AD_R_OFFSET;
    Data[7]     = stGUD2.AD_G_OFFSET;
    Data[8]     = stGUD2.AD_B_OFFSET;

    I2CWrite(Data);
    Delay_Xms(SET_2404_DELAY);
}

void Load_GUD2(void)
{
    I2CRead(ADDR_EROM1, 0xF0 , 6);
    
    stGUD2.AD_R_GAIN    = Data[0];
    stGUD2.AD_G_GAIN    = Data[1];
    stGUD2.AD_B_GAIN    = Data[2];
    stGUD2.AD_R_OFFSET  = Data[3];
    stGUD2.AD_G_OFFSET  = Data[4];
    stGUD2.AD_B_OFFSET  = Data[5];
}


void Save_GUD3(void)
{
#if (TV_CHIP != TV_NONE)
    Data[0]     = 7;
    Data[1]     = ADDR_EROM1;
    Data[2]     = 0xF8;
    Data[3]     = stGUD3.VOLUME;
    Data[4]     = stGUD3.CURR_CHANNEL;
    Data[5]     = stGUD3.PREV_CHANNEL;
    Data[6]     = stGUD3.TV_SETTING;
#else
    Data[0]     = 4;
    Data[1]     = ADDR_EROM1;
    Data[2]     = 0xF8;
    Data[3]     = stGUD3.VOLUME;
#endif

    I2CWrite(Data);
    Delay_Xms(SET_2404_DELAY);
}

void Load_GUD3(void)
{
    I2CRead(ADDR_EROM1, 0xF8 , 4);
    
    stGUD3.VOLUME       = Data[0];
#if (TV_CHIP != TV_NONE)
    stGUD3.CURR_CHANNEL = Data[1];
    stGUD3.PREV_CHANNEL = Data[2];
    stGUD3.TV_SETTING   = Data[3];
#endif
}

/*
// Not used in standard code
void Save_GUD4(void)
{
    Data[0]     = 12;
    Data[1]     = ADDR_EROM1;
    Data[2]     = 0xD0;
    Data[3]     = stGUD4.C1_R;
    Data[4]     = stGUD4.C1_G;
    Data[5]     = stGUD4.C1_B;
    Data[6]     = stGUD4.C2_R;
    Data[7]     = stGUD4.C2_G;
    Data[8]     = stGUD4.C2_B;
    Data[9]     = stGUD4.C3_R;
    Data[10]    = stGUD4.C3_G;
	Data[11]    = stGUD4.C3_B;
    I2CWrite(Data);

    Delay_Xms(SET_2404_DELAY);
}
*/

void Load_GUD4(void)
{
    I2CRead(ADDR_EROM1, 0xD0 , 9);

    stGUD4.C1_R   = Data[0];
    stGUD4.C1_G   = Data[1];
    stGUD4.C1_B   = Data[2];
    stGUD4.C2_R   = Data[3];
    stGUD4.C2_G   = Data[4];
    stGUD4.C2_B   = Data[5];
    stGUD4.C3_R   = Data[6];
    stGUD4.C3_G   = Data[7];
	stGUD4.C3_B   = Data[8];
}


void Save_MUD(unsigned char mode_num)
{
    if (0 == mode_num || 64 < mode_num)  return;
    
    Data[0] = 7;
    Data[1] = ADDR_EROM0;
    Data[2] = (mode_num - 1) << 2;	        
    Data[3] = stMUD.H_POSITION;
    Data[4] = stMUD.V_POSITION;
    Data[5] = stMUD.CLOCK;
    Data[6] = (stMUD.PHASE & 0x7c);// | (stMUD.P_Code - 0x19);
    I2CWrite(Data);
    
    Delay_Xms(SET_2404_DELAY);
}

void Load_MUD(unsigned char mode_num)
{
    if (0 == mode_num || 64 < mode_num)  return;

    I2CRead(ADDR_EROM0, (mode_num - 1) << 2, 4);

    stMUD.H_POSITION    = Data[0];
    stMUD.V_POSITION    = Data[1];
    stMUD.CLOCK         = Data[2];
    stMUD.PHASE         = Data[3] & 0x7c;
}

void Init_GUD(void)     // GU <= Default
{
    stGUD0.CONTRAST         = INIT_EEPROM0[3];
    stGUD0.BRIGHT           = INIT_EEPROM0[4];
    stGUD0.RTD_R_CONTRAST   = INIT_EEPROM0[5];
    stGUD0.RTD_G_CONTRAST   = INIT_EEPROM0[6];
    stGUD0.RTD_B_CONTRAST   = INIT_EEPROM0[7];
    stGUD0.RTD_R_BRIGHT     = INIT_EEPROM0[8];
    stGUD0.RTD_G_BRIGHT     = INIT_EEPROM0[9];
    stGUD0.RTD_B_BRIGHT     = INIT_EEPROM0[10];

    stGUD1.FUNCTION         = INIT_EEPROM0[11];
    stGUD1.INPUT_SOURCE     = INIT_EEPROM0[12];
    stGUD1.FILTER           = INIT_EEPROM0[13];
    stGUD1.OSD_POSH         = INIT_EEPROM0[14];
    stGUD1.OSD_POSV         = INIT_EEPROM0[15];
    stGUD1.OSD_TIMEOUT      = INIT_EEPROM0[16];

    stGUD2.AD_R_GAIN        = INIT_EEPROM1[3];
    stGUD2.AD_G_GAIN        = INIT_EEPROM1[4];
    stGUD2.AD_B_GAIN        = INIT_EEPROM1[5];
    stGUD2.AD_R_OFFSET      = INIT_EEPROM1[6];
    stGUD2.AD_G_OFFSET      = INIT_EEPROM1[7];
    stGUD2.AD_B_OFFSET      = INIT_EEPROM1[8];

    stGUD3.VOLUME           = INIT_EEPROM1[11];
#if (TV_CHIP != TV_NONE)
    stGUD3.CURR_CHANNEL     = INIT_EEPROM1[12];
    stGUD3.PREV_CHANNEL     = INIT_EEPROM1[13];
    stGUD3.TV_SETTING       = INIT_EEPROM1[14];
#endif

	stGUD4.C1_R             = INIT_EEPROM2[3];
	stGUD4.C1_G             = INIT_EEPROM2[4];
	stGUD4.C1_B             = INIT_EEPROM2[5];
	stGUD4.C2_R             = INIT_EEPROM2[6];
	stGUD4.C2_G             = INIT_EEPROM2[7];
	stGUD4.C2_B             = INIT_EEPROM2[8];
	stGUD4.C3_R             = INIT_EEPROM2[9];
	stGUD4.C3_G             = INIT_EEPROM2[10];
	stGUD4.C3_B             = INIT_EEPROM2[11];

	
    I2CWrite(INIT_EEPROM0);
    Delay_Xms(SET_2404_DELAY);

    I2CWrite(INIT_EEPROM1);
    Delay_Xms(SET_2404_DELAY);

	I2CWrite(INIT_EEPROM2);
    Delay_Xms(SET_2404_DELAY);	
}

void Init_MUD(void)
{
    unsigned char   ucModeIdx;

    // Reset frame-Sync and TV channel settings
    Data[0]     = 11;
    Data[1]     = ADDR_EROM1;
    Data[2]     = 0;
    Data[3]     = 0x00;
    Data[4]     = 0x00;