scaler.c

realtek LCD monitor, TV开发源代码

    }

    CScalerWrite(ucAddr, 1, &ucValue, _AUTOINC);
    CScalerRead(ucAddr + 1, 1, &value, _AUTOINC);

    return (value & ucAnd);
}
#endif  // End of #if(_ADC_OFFSET_ADJUSTING == _ADJUST_BY_HW_OFF_LINE)
*/

//--------------------------------------------------
// Description  : Write a table into scaler
// Input Value  : pArray    --> Selected table which contains numbers, address auto increasing information, address of registers and values
// Output Value : None
//--------------------------------------------------
void CScalerCodeW(BYTE *pArray)
{
    BYTE length;

#if(_MCU_TYPE == _REALTEK_EMBEDDED)

    do
    {
        if((*pArray & 0xfc) == 0)
            return;

        length  = *pArray - 3;

        if((*(pArray + 1)) == _BURST)
        {
            *(&MCU_SCA_INF_CTRL_FFF3) |= 0x20;//Anderson 080310
            *(&MCU_SCA_INF_ADDR_FFF4) = *(pArray + 2);

            pArray += 3;

            do
            {
                *(&MCU_SCA_INF_DATA_FFF5) = *pArray;

            }while(--length);

            pArray++;
        }
        else if((*(pArray + 1) == _AUTOINC) || (*(pArray + 1) == _NON_AUTOINC))
        {

            if(*(pArray + 1) == _NON_AUTOINC)
                *(&MCU_SCA_INF_CTRL_FFF3) |= 0x20;//Anderson 080310
            else
                *(&MCU_SCA_INF_CTRL_FFF3) &= 0xDF;//Anderson 080310

            *(&MCU_SCA_INF_ADDR_FFF4) = *(pArray + 2);

            pArray += 3;

            do
            {
                *(&MCU_SCA_INF_DATA_FFF5) = *pArray++;

            }while(--length);

        }

    }while(_TRUE);


#else


    do
    {
        if((*pArray & 0xfc) == 0)
            return;

        length  = *pArray - 3;

        if((*(pArray + 1)) == _BURST)
        {
            CScalerSendAddr(*(pArray + 2), _WRITE, _NON_AUTOINC);

            pArray += 3;

            do
            {
                CScalerSendByte(*pArray);

            }while(--length);

            pArray++;
        }
        else if((*(pArray + 1) == _AUTOINC) || (*(pArray + 1) == _NON_AUTOINC))
        {
            CScalerSendAddr(*(pArray + 2), _WRITE, *(pArray + 1));

            pArray += 3;

            do
            {
                CScalerSendByte(*pArray++);

            }while(--length);

        }

        CScalerSendWriteStop();

    }while(_TRUE);

#endif  // End of #if(_MCU_TYPE == _REALTEK_EMBEDDED)
}

#if(_LOAD_FONT_TYPE == _HARD_WARE)
//--------------------------------------------------
// Description  : Load OSD font into OSD SRAM
// Input Value  : pArray    --> Font table
//                usOffset  --> Offset of font base start address
// Output Value : None
//--------------------------------------------------
void CScalerLoadHardwareVLCFont(BYTE *pArray, WORD usOffset)
{
    WORD num;

#if(_OSD_ROTATE_FUCTION == _ON)
    if(GET_ROTATE_STATUS())
        num = 0x85;
    else
#endif
        num = 0x00;

    CScalerSetByte(_OSD_ADDR_MSB_90,0x80);          // Byte2
    CScalerSetByte(_OSD_ADDR_LSB_91,0x03);          // Address : 003h
    CScalerSetByte(_OSD_DATA_PORT_92,(BYTE)num);    // CCW swap, Rotation


    CScalerSetByte(_OSD_ADDR_MSB_90, 0xc0);
    CScalerSetByte(_OSD_ADDR_LSB_91, 0x05);
    CScalerWrite(_OSD_DATA_PORT_92, 8, pArray, _NON_AUTOINC);

    num = ((WORD)*(pArray + 8) << 8) | *(pArray + 9);

#if(_OSD_ROTATE_FUCTION == _ON)
    if(GET_ROTATE_STATUS())
    {
        usOffset = usOffset * 12;
        usOffset += _OSD_FONT_START_POSITION_ROTATE;
    }
    else
#endif
    {
    usOffset = usOffset * 9;

#if(_OSD_TYPE == _BENQ_OSD)
    usOffset += _OSD_FONT_START_POSITION_BENQ;
#else//_GENERIC_OSD
    usOffset += _OSD_FONT_START_POSITION_GENERIC;
#endif
    }

    CScalerSetByte(_OSD_ADDR_MSB_90, 0x80);
    CScalerSetByte(_OSD_ADDR_LSB_91, 0x07);
    CScalerSetByte(_OSD_DATA_PORT_92, 0x01);

    //20080121 Sephinroth Modified for osd load font > 12K
    if(usOffset > 4095)
       CScalerSetBit(_OSD_SCRAMBLE_93,~_BIT3, _BIT3);
    else
        CScalerSetBit(_OSD_SCRAMBLE_93,~_BIT3, 0x00);
#if(_MCU_TYPE == _REALTEK_EMBEDDED)

    *(&MCU_SCA_INF_CTRL_FFF3) &= 0xDF;//Anderson 080310
    MCU_SCA_INF_ADDR_FFF4 = _OSD_ADDR_MSB_90;
    *(&MCU_SCA_INF_DATA_FFF5) = (HIBYTE(usOffset) & 0x000f) | 0xd0;
    *(&MCU_SCA_INF_DATA_FFF5) = LOBYTE(usOffset);

    pArray += 10;

    *(&MCU_SCA_INF_CTRL_FFF3) |= 0x20;//Anderson 080310
    *(&MCU_SCA_INF_ADDR_FFF4) = _OSD_DATA_PORT_92;

    for(usOffset=0;usOffset<num;usOffset++)
    {
        *(&MCU_SCA_INF_DATA_FFF5) = *pArray++;
    }

#else

    CScalerSendAddr(_OSD_ADDR_MSB_90, _WRITE, _AUTOINC);
    CScalerSendByte((HIBYTE(usOffset) & 0x000f) | 0xd0);
    CScalerSendByte(LOBYTE(usOffset));
    CScalerSendWriteStop();

    pArray += 10;

    CScalerSendAddr(_OSD_DATA_PORT_92, _WRITE, _NON_AUTOINC);

    for(usOffset=0;usOffset<num;usOffset++)
    {
        CScalerSendByte(*pArray++);
    }

    CScalerSendWriteStop();

#endif
    //20080121 Sephinroth Modified for osd load font > 12K !!
    CScalerSetBit(_OSD_SCRAMBLE_93,~_BIT3, 0x00);

    CScalerSetByte(_OSD_ADDR_MSB_90, 0x80);
    CScalerSetByte(_OSD_ADDR_LSB_91, 0x07);
    CScalerSetByte(_OSD_DATA_PORT_92, 0x00);

#if(_OSD_ROTATE_FUCTION == _ON)
    CScalerSetByte(_OSD_ADDR_MSB_90, 0x80);
    CScalerSetByte(_OSD_ADDR_LSB_91, 0x03);
    CScalerSetByte(_OSD_DATA_PORT_92, ((BYTE)GET_ROTATE_STATUS()));
#endif

}
#endif  // End of #if(_LOAD_FONT_TYPE == _HARD_WARE)


#if(_LOAD_FONT_TYPE == _SOFT_WARE)

//--------------------------------------------------
// Description  : Load OSD font into OSD SRAM
// Input Value  : pArray    --> Font table
//                usOffset  --> Offset of font base start address
//                usLength  --> Font amounts we want to load (unit in 1 bit font)
//                ucPar     --> Choose normal or compress font table
// Output Value : None
//--------------------------------------------------
void CScalerLoadFont(BYTE *pArray, WORD usOffset, WORD usLength, BYTE ucPar)
{
    BYTE temp0, temp1, temp2;

    if(usLength == 0)
        return;

    usOffset = usOffset * 9;
    usOffset += _OSD_FONT_START_POSITION;
    //20080121 Sephinroth Modified // cyyeh 20080128
    if(usOffset >4095)
        CScalerSetBit(_OSD_SCRAMBLE_93,~_BIT3, _BIT3);

    CScalerSetByte(_OSD_ADDR_MSB_90, ((HIBYTE(usOffset) & 0x000f) | 0xd0));
    CScalerSetByte(_OSD_ADDR_LSB_91, (LOBYTE(usOffset)));

    if(ucPar == _COMPRESS_FONT)
    {
        ucVLDCnt    = 0;
        ucVLDTemp   = 0;
        pvldarray   = (pArray + 16);

        for(temp0=0;temp0<16;temp0++)
            pData[temp0] = *(pArray + temp0);
    }

    do
    {
        for (usOffset=0;usOffset<9;usOffset++)
        {
            if(ucPar == _COMPRESS_FONT)
            {
                temp0   = CScalerGetVLD() << 4;
                temp0   |= CScalerGetVLD();
                temp1   = CScalerGetVLD() << 4;
                temp1   |= CScalerGetVLD();
                temp2   = CScalerGetVLD() << 4;
                temp2   |= CScalerGetVLD();
            }
            else
            {
                temp0 = *pArray++;
                temp1 = *pArray++;
                temp2 = *pArray++;
            }

            CScalerSetByte(_OSD_DATA_PORT_92, ((temp1 << 4) | (temp2 & 0x0f)));
            CScalerSetByte(_OSD_DATA_PORT_92, ((temp2 & 0xf0) | (temp0 & 0x0f)));
            CScalerSetByte(_OSD_DATA_PORT_92, ((temp0 & 0xf0) | (temp1 >> 4)));
        }
    }
    while(--usLength);

    //20080121 Sephinroth Modified //cyyeh 20080128
    CScalerSetBit(_OSD_SCRAMBLE_93,~_BIT3, 0x00);
}

BYTE CScalerGetVLD(void)
{
    BYTE zerocnt = 0;

    while(!CScalerGetBitVLD())   zerocnt  += 1;

    if(zerocnt == 0)    return *(pData);

    switch(zerocnt)
    {
        case 1:
            return (CScalerGetBitVLD() ? *(pData + 1) : *(pData + 2));

        case 2:
            return (CScalerGetBitVLD() ? *(pData + 3) : *(pData + 4));

        case 3:
            return (CScalerGetBitVLD() ? *(pData + 5) : *(pData + 6));

        case 4:
            if (CScalerGetBitVLD())
            {
                return (CScalerGetBitVLD() ? *(pData + 7) : *(pData + 8));
            }
            else
            {
                if (CScalerGetBitVLD())
                {
                    return (CScalerGetBitVLD() ? *(pData + 9) : *(pData + 10));
                }
                else
                {
                    return (CScalerGetBitVLD() ? *(pData + 11) : *(pData + 12));
                }
            }

        default:
            if (CScalerGetBitVLD())
            {
                return (CScalerGetBitVLD() ? *(pData + 13) : *(pData + 14));
            }
            else
            {
                CScalerGetBitVLD();

                return *(pData + 15);
            }
    }
}

bit CScalerGetBitVLD(void)
{
    ucVLDTemp = ((ucVLDCnt & 0x07) == 0) ? *(pvldarray++) : (ucVLDTemp << 1);

    ucVLDCnt += 1;

    return (bit)(ucVLDTemp & 0x80);
}

#endif  // End of #if(_LOAD_FONT_TYPE == _SOFT_WARE)



#if(_OSD_ROTATE_FUCTION == _ON)
//--------------------------------------------------
// Description  : None
// Input Value  : None
// Output Value : None
//--------------------------------------------------
void CScalerSendRotateByte(void)
{
   BYTE x;
   for(x=0;x<3;x++)
   {
      CScalerSendByte(((ROTATETemp[26-x]<<3)&0x88));
      CScalerSendByte((((ROTATETemp[14-x]<<3)&0x88)+((ROTATETemp[17-x]<<2)&0x44)+((ROTATETemp[20-x]<<1)&0x22)+(ROTATETemp[23-x]&0x11)));
      CScalerSendByte((((ROTATETemp[2-x]<<3)&0x88)+((ROTATETemp[5-x]<<2)&0x44)+((ROTATETemp[8-x]<<1)&0x22)+(ROTATETemp[11-x]&0x11)));

      CScalerSendByte(((ROTATETemp[26-x]<<2)&0x88));
      CScalerSendByte((((ROTATETemp[14-x]<<2)&0x88)+((ROTATETemp[17-x]<<1)&0x44)+(ROTATETemp[20-x]&0x22)+((ROTATETemp[23-x]>>1)&0x11)));
      CScalerSendByte((((ROTATETemp[2-x]<<2)&0x88)+((ROTATETemp[5-x]<<1)&0x44)+(ROTATETemp[8-x]&0x22)+((ROTATETemp[11-x]>>1)&0x11)));

      CScalerSendByte(((ROTATETemp[26-x]<<1)&0x88));
      CScalerSendByte((((ROTATETemp[14-x]<<1)&0x88)+(ROTATETemp[17-x]&0x44)+((ROTATETemp[20-x]>>1)&0x22)+((ROTATETemp[23-x]>>2)&0x11)));
      CScalerSendByte((((ROTATETemp[2-x]<<1)&0x88)+(ROTATETemp[5-x]&0x44)+((ROTATETemp[8-x]>>1)&0x22)+((ROTATETemp[11-x]>>2)&0x11)));

      CScalerSendByte((ROTATETemp[26-x]&0x88));
      CScalerSendByte(((ROTATETemp[14-x]&0x88)+((ROTATETemp[17-x]>>1)&0x44)+((ROTATETemp[20-x]>>2)&0x22)+((ROTATETemp[23-x]>>3)&0x11)));
      CScalerSendByte(((ROTATETemp[2-x]&0x88)+((ROTATETemp[5-x]>>1)&0x44)+((ROTATETemp[8-x]>>2)&0x22)+((ROTATETemp[11-x]>>3)&0x11)));
   }
}

#endif // End of #if(_OSD_ROTATE_FUCTION == _ON)

#if(_DP_SUPPORT == _ON)

//--------------------------------------------------
// Description  : Read data from registers of scaler and put it into an reading data array
// Input Value  : ucAddr    --> Start address of register
//                ucLength  --> Numbers of data we want to read
//                pArray    --> Pointer of the reading data array
//                bAutoInc  --> Address auto increasing select
// Output Value : None
//--------------------------------------------------
void CScalerReadByteInt(BYTE ucAddr, BYTE *pArray)
        {
#if(_MCU_TYPE == _REALTEK_EMBEDDED)

    MCU_SCA_INF_ADDR_FFF4 = ucAddr;
    *pArray = MCU_SCA_INF_DATA_FFF5;

#endif

        }

//--------------------------------------------------
// Description  : Set the value into selected register
// Input Value  : ucAddr    --> Address of register
//                ucValue   --> Value we want to set
// Output Value : None
//--------------------------------------------------
void CScalerSetByteInt(BYTE ucAddr, BYTE ucValue)
{

    MCU_SCA_INF_ADDR_FFF4 = ucAddr;
    MCU_SCA_INF_DATA_FFF5 = ucValue;

    }

#endif //End of #if(_DP_SUPPORT == _ON)

#endif  // End of #if(_SCALER_SERIES_TYPE == _RTD2472D_SERIES)