/*=============================================
  * Copyright (c)      Realtek Semiconductor Corporation, 2005
  * All rights reserved.
  * ============================================ */

#define __RTDACCESS__


#include "Core\Header\Include.h"

/*===================== Module dependency  ================== */

/*======================= Private Types ===================== */


/*======================== Definitions ====================== */

/*========================== Variables ====================== */


/*=================== Local Functions Phototype ==============*/

/*=========================== Functions ===================== */

/**
 * This is the function to process Ir.
 */

//----------------------------------------------------------------------------------------------------
// Scaler communication basic function
//----------------------------------------------------------------------------------------------------
#if(_MCU_TYPE != _REALTEK_RTD2662_EMCU)
void CScalerSendReadStop(void)
{
#if(_HOST_INTERFACE == _PARALLEL_PORT)
    SETSCALERSCSB();
    SETSCALERSCLK();
#elif(_HOST_INTERFACE == _SERIAL_PORT)
    SETSCALERSCLK();
    SETSCALERSCSB();
#endif
	if (bVBI_INT_Enable)
		ET1 = 1;
}

void CScalerSendWriteStop(void)
{
#if(_HOST_INTERFACE == _PARALLEL_PORT)
    SETSCALERSCLK();
    SETSCALERSCSB();
#elif(_HOST_INTERFACE == _SERIAL_PORT)
    CLRSCALERSCLK();
    SETSCALERSCLK();
    SETSCALERSCLK();
    SETSCALERSCSB();
#endif
    if (bVBI_INT_Enable)
		ET1 = 1;
}

void CScalerSendAddr(BYTE ucAddr, bit bReadWrite, bit bAutoInc)
{
	ET1 = 0;
#if(_HOST_INTERFACE == _PARALLEL_PORT)

    CLRSCALERSCSB();

    SETSCALERSDIO0((bit)(ucAddr & 0x01));
    SETSCALERSDIO1((bit)(ucAddr & 0x02));
    SETSCALERSDIO2((bit)(ucAddr & 0x04));
    SETSCALERSDIO3((bit)(ucAddr & 0x08));
    CLRSCALERSCLK();

    SETSCALERSDIO0((bit)(ucAddr & 0x10));
    SETSCALERSDIO1((bit)(ucAddr & 0x20));
    SETSCALERSDIO2((bit)(ucAddr & 0x40));
    SETSCALERSDIO3((bit)(ucAddr & 0x80));
    SETSCALERSCLK();

    SETSCALERSDIO0(bReadWrite);
    SETSCALERSDIO1(bAutoInc);
    CLRSCALERSCLK();

    SETSCALERSDIO0(_HIGH);
    SETSCALERSDIO1(_HIGH);
    SETSCALERSDIO2(_HIGH);
    SETSCALERSDIO3(_HIGH);

#elif(_HOST_INTERFACE == _SERIAL_PORT)
    CLRSCALERSCSB();
    CScalerSendByte(ucAddr);
    SETSCALERSDIO3(bReadWrite);
    CLRSCALERSCLK();
    SETSCALERSDIO3(bAutoInc);
    SETSCALERSCLK();
    SETSCALERSDIO3(_HIGH);
#endif
}

void CScalerSendByte(BYTE ucValue)
{
#if(_HOST_INTERFACE == _PARALLEL_PORT)
    SETSCALERSDIO0((bit)(ucValue & 0x01));
    SETSCALERSDIO1((bit)(ucValue & 0x02));
    SETSCALERSDIO2((bit)(ucValue & 0x04));
    SETSCALERSDIO3((bit)(ucValue & 0x08));
    SETSCALERSCLK();
    SETSCALERSDIO0((bit)(ucValue & 0x10));
    SETSCALERSDIO1((bit)(ucValue & 0x20));
    SETSCALERSDIO2((bit)(ucValue & 0x40));
    SETSCALERSDIO3((bit)(ucValue & 0x80));
    CLRSCALERSCLK();
#elif(_HOST_INTERFACE == _SERIAL_PORT)
    SETSCALERSDIO3((bit)(ucValue & 0x01));
    CLRSCALERSCLK();
    SETSCALERSDIO3((bit)(ucValue & 0x02));
    SETSCALERSCLK();
    SETSCALERSDIO3((bit)(ucValue & 0x04));
    CLRSCALERSCLK();
    SETSCALERSDIO3((bit)(ucValue & 0x08));
    SETSCALERSCLK();
    SETSCALERSDIO3((bit)(ucValue & 0x10));
    CLRSCALERSCLK();
    SETSCALERSDIO3((bit)(ucValue & 0x20));
    SETSCALERSCLK();
    SETSCALERSDIO3((bit)(ucValue & 0x40));
    CLRSCALERSCLK();
    SETSCALERSDIO3((bit)(ucValue & 0x80));
    SETSCALERSCLK();
#endif
}

BYTE CScalerGetByte(void)
{

#if(_HOST_INTERFACE == _PARALLEL_PORT)

    BYTE value = 0;

    SETSCALERSCLK();

    SETSCALERSCLK();
    SETSCALERSCLK();
    SETSCALERSCLK();
    SETSCALERSCLK();

    if(GETSCALERSDIO0())
        value   |= 0x01;
    if(GETSCALERSDIO1())
        value   |= 0x02;
    if(GETSCALERSDIO2())
        value   |= 0x04;
    if(GETSCALERSDIO3())
        value   |= 0x08;
    CLRSCALERSCLK();

    SETSCALERSCLK();
    SETSCALERSCLK();
    SETSCALERSCLK();
    SETSCALERSCLK();

    if(GETSCALERSDIO0())
        value   |= 0x10;
    if(GETSCALERSDIO1())
        value   |= 0x20;
    if(GETSCALERSDIO2())
        value   |= 0x40;
    if(GETSCALERSDIO3())
        value   |= 0x80;

#elif(_HOST_INTERFACE == _SERIAL_PORT)

    BYTE value = 0;

    CLRSCALERSCLK();
    if(GETSCALERSDIO3())
        value   |= 0x01;
    SETSCALERSCLK();
    if(GETSCALERSDIO3())
        value   |= 0x02;
    CLRSCALERSCLK();
    if(GETSCALERSDIO3())
        value   |= 0x04;
    SETSCALERSCLK();
    if(GETSCALERSDIO3())
        value   |= 0x08;
    CLRSCALERSCLK();
    if(GETSCALERSDIO3())
        value   |= 0x10;
    SETSCALERSCLK();
    if(GETSCALERSDIO3())
        value   |= 0x20;
    CLRSCALERSCLK();
    if(GETSCALERSDIO3())
        value   |= 0x40;
    SETSCALERSCLK();
    if(GETSCALERSDIO3())
        value   |= 0x80;

#endif

    return value;
}
#endif

//--------------------------------------------------
// Description  : Write a data array into registers of scaler
// Input Value  : ucAddr    --> Start address of register
//                ucLength  --> Numbers of data we want to write
//                pArray    --> Pointer of the writing data array
//                bAutoInc  --> Address auto increasing select
// Output Value : None
//--------------------------------------------------
void CScalerWrite(BYTE ucAddr, WORD usLength, BYTE *pArray, bit bAutoInc)
{
#if(_MCU_TYPE == _REALTEK_RTD2662_EMCU)

    if(bAutoInc)
        *(&MCU_SCA_INF_CTRL_FFF3) = 0x20;
    else
        *(&MCU_SCA_INF_CTRL_FFF3) = 0x00;

    if(usLength > 0)
    {
        *(&MCU_SCA_INF_ADDR_FFF4) = ucAddr;

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

        }while(--usLength);
    }

#else

    if(usLength > 0)
    {
        CScalerSendAddr(ucAddr, _WRITE, bAutoInc);
        do
        {
            CScalerSendByte(*pArray++);

        }while(--usLength);
        CScalerSendWriteStop();
    }
		
#endif		
}

//--------------------------------------------------
// 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 CScalerRead(BYTE ucAddr, BYTE ucLength, BYTE *pArray, bit bAutoInc)
{
#if(_MCU_TYPE == _REALTEK_RTD2662_EMCU)

    if(bAutoInc)
        *(&MCU_SCA_INF_CTRL_FFF3) = 0x20;
    else
        *(&MCU_SCA_INF_CTRL_FFF3) = 0x00;

    if(ucLength > 0)
    {
        *(&MCU_SCA_INF_ADDR_FFF4) = ucAddr;

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

        }while(--ucLength);

    }

#else

    if(ucLength > 0)
    {
        CScalerSendAddr(ucAddr, _READ, bAutoInc);
        do
        {
            *pArray++ = CScalerGetByte();

        }while(--ucLength);
        CScalerSendReadStop();
    }
		
#endif
}

/**
* CScalerWriteAmount
* Write a data array into register of scaler
* @param <ucAddress> {Start address of register}
* @param <ucCol> {The colume of blank}
* @param <ucLength> {Number of data}
* @param <ucValue> {The data wroten}
* @param <bAutoInc> {Address auto increase or not}
* @return {none}
*
*/
void CScalerWriteAmount(BYTE ucAddr, WORD usLength, BYTE ucValue, bit bAutoInc)
{
#if(_MCU_TYPE == _REALTEK_RTD2662_EMCU)

    if(bAutoInc)
        *(&MCU_SCA_INF_CTRL_FFF3) = 0x20;
    else
        *(&MCU_SCA_INF_CTRL_FFF3) = 0x00;

    if(usLength > 0)
    {
        *(&MCU_SCA_INF_ADDR_FFF4) = ucAddr;

        do
        {
            *(&MCU_SCA_INF_DATA_FFF5) = ucValue;

        }while(--usLength);
    }

#else

    if(usLength > 0)
    {
        CScalerSendAddr(ucAddr, _WRITE, bAutoInc);
        do
        {
            CScalerSendByte(ucValue);

        }while(--usLength);
        CScalerSendWriteStop();
    }
		
#endif
}


//--------------------------------------------------
// Description  : Set the value into selected register
// Input Value  : ucAddr    --> Address of register
//                ucValue   --> Value we want to set
// Output Value : None
//--------------------------------------------------
void CScalerSetByte(BYTE ucAddr, BYTE ucValue)
{
    CScalerWrite(ucAddr, 1, &ucValue, _AUTOINC);
}

//--------------------------------------------------
// Description  : Set the value into selected register in data port
// Input Value  : ucAddr    --> Access Port Address of register
//                ucValue1  --> Data Port Value we want to set
//                ucValue2  --> Data Value we want to set
// Output Value : None
//--------------------------------------------------
void CScalerSetDataPortByte(BYTE ucAddr, BYTE ucValue1, BYTE ucValue2)
{
#if(_SCALER_TYPE==_RTD2662)
    if((ucAddr == _SU_ACCESS_PORT_33) || (ucAddr == _HW_ACCESS_PORT_60) 
    || (ucAddr == _CB_ACCESS_PORT_64) || (ucAddr == _PC_ACCESS_PORT_9A))
#else
    if((ucAddr == _SD_ACCESS_PORT_24) || (ucAddr == _SU_ACCESS_PORT_33) ||
       (ucAddr == _HW_ACCESS_PORT_60) || (ucAddr == _CB_ACCESS_PORT_64) ||
       (ucAddr == _PC_ACCESS_PORT_9A) || (ucAddr == _CMDI_ACCESS_PORT_F0))
#endif
    {
        CScalerSetByte(ucAddr, 0x80);
        ucValue1 = ucValue1 | 0x80;
    }
    CScalerWrite(ucAddr, 1, &ucValue1, _AUTOINC);
    CScalerWrite(ucAddr + 1, 1, &ucValue2, _AUTOINC);
    CScalerSetByte(ucAddr, 0x00);
}

/**
* CScalerSetBit
* Set bit of register
* @param <ucAddr> {register address}
* @param <ucAnd> {data &}
* @param <ucOr> {data |}
* @return {none}
*
*/
void CScalerSetBit(BYTE ucAddr, BYTE ucAnd, BYTE ucOr)
{
    BYTE value;

    CScalerRead(ucAddr, 1, &value, _AUTOINC);
    value   = (value & ucAnd) | ucOr;
    CScalerWrite(ucAddr, 1, &value, _AUTOINC);
}


//--------------------------------------------------
// Description  : Set some bits of selected register in data port
// Input Value  : ucAddr    --> Access Port Address of register
//                ucValue   --> Data Port Value we want to set
//                ucAnd     --> & operation
//                ucOr      --> | operation
// Output Value : None
//--------------------------------------------------

void CScalerSetDataPortBit(BYTE ucAddr, BYTE ucValue, BYTE ucAnd, BYTE ucOr)
{
    BYTE value;

#if(_SCALER_TYPE==_RTD2662)
    if((ucAddr == _SU_ACCESS_PORT_33) || (ucAddr == _HW_ACCESS_PORT_60) 
    || (ucAddr == _CB_ACCESS_PORT_64) || (ucAddr == _PC_ACCESS_PORT_9A))
#else
    if((ucAddr == _SD_ACCESS_PORT_24) || (ucAddr == _SU_ACCESS_PORT_33) ||
       (ucAddr == _HW_ACCESS_PORT_60) || (ucAddr == _CB_ACCESS_PORT_64) ||
       (ucAddr == _PC_ACCESS_PORT_9A) || (ucAddr == _CMDI_ACCESS_PORT_F0))
#endif
    {
        CScalerSetByte(ucAddr, 0x80);
        ucValue = ucValue | 0x80;
    }

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

    value   = (value & ucAnd) | ucOr;
#if(_SCALER_TYPE==_RTD2662)
    if((ucAddr == _SU_ACCESS_PORT_33) || (ucAddr == _HW_ACCESS_PORT_60) 
    || (ucAddr == _CB_ACCESS_PORT_64) || (ucAddr == _PC_ACCESS_PORT_9A))
#else
    if((ucAddr == _SD_ACCESS_PORT_24) || (ucAddr == _SU_ACCESS_PORT_33) ||
       (ucAddr == _HW_ACCESS_PORT_60) || (ucAddr == _CB_ACCESS_PORT_64) ||
       (ucAddr == _PC_ACCESS_PORT_9A) || (ucAddr == _CMDI_ACCESS_PORT_F0))
#endif       
    {
        CScalerSetByte(ucAddr, 0x80);
        ucValue = ucValue | 0x80;
    }

    CScalerWrite(ucAddr, 1, &ucValue, _AUTOINC);
    CScalerWrite(ucAddr + 1, 1, &value, _AUTOINC);
    CScalerSetByte(ucAddr, 0x00);
}


//--------------------------------------------------
// Description  : Get bits from selected register
// Input Value  : ucAddr    --> Address of register
//                ucAnd     --> & operation
// Output Value : Value after & operation
//--------------------------------------------------
BYTE CScalerGetBit(BYTE ucAddr, BYTE ucAnd)
{
    BYTE value;

    CScalerRead(ucAddr, 1, &value, _AUTOINC);
    return (value & ucAnd);
}

/**
* CScalerCodeW
* Write a table to scaler
* @param <pArray> {Selected table which contains numbers, address auto increasing information, address of registers and values}
* @return {none}
*
*/
void CScalerCodeW(BYTE *pArray)
{
    BYTE length;

#if(_MCU_TYPE == _REALTEK_RTD2662_EMCU)

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

        length  = *pArray - 3;

        if((*(pArray + 1)) == _BURST)
        {
            *(&MCU_SCA_INF_CTRL_FFF3) = 0x20;
            *(&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;
            else
                *(&MCU_SCA_INF_CTRL_FFF3) = 0x00;

            *(&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		
}
#if(_HARDWARE_LOAD_FONT != _ON)	
//--------------------------------------------------
// Description  : Load OSD font into the absoulte address in OSD SRAM
// Input Value  : pArray    --> Font table
//                usStartAddr  --> start absolute address address
//                usLength  --> Font amounts we want to load (unit in 1 bit font)
//                ucPar     --> Choose normal or compress font table
// Output Value : None
//--------------------------------------------------
void CScalerLoadFontInAbAddr(BYTE code *pArray, WORD usStartAddr, WORD usLength, BYTE ucPar)
{
	BYTE temp0, temp1, temp2;

#if(_SCALER_TYPE==_RTD2662)
    CScalerSetByte(_OSD_ADDR_MSB_90, (HIBYTE(usStartAddr) & 0x000f) | 0xd0);
    CScalerSetByte(_OSD_ADDR_LSB_91, LOBYTE(usStartAddr));
#else
	CScalerSendAddr(_OSD_ADDR_MSB_90, _WRITE, _AUTOINC);					
	CScalerSendByte((HIBYTE(usStartAddr) & 0x000f) | 0xd0);						
	CScalerSendByte(LOBYTE(usStartAddr));														
	CScalerSendWriteStop();																				
#endif		

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

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

#if(_SCALER_TYPE!=_RTD2662)
	CScalerSendAddr(_OSD_DATA_PORT_92, _WRITE, _NON_AUTOINC);		
#endif	
	do {
		for (usStartAddr=0;usStartAddr<9;usStartAddr++) {
			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++;
			}
#if(_SCALER_TYPE==_RTD2662)
			// Rearrange the byte order
            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)));
#else
			// Rearrange the byte order
			CScalerSendByte((temp1 << 4) | (temp2 & 0x0f));							
			CScalerSendByte((temp2 & 0xf0) | (temp0 & 0x0f));						
			CScalerSendByte((temp0 & 0xf0) | (temp1 >> 4));							
#endif						
		}
	}while(--usLength);
#if(_SCALER_TYPE!=_RTD2662)	
	CScalerSendWriteStop();		
#endif	
}
#endif
/**
* CScalerLoadFont
* Load OSD font into OSD RAM
* @param <pArray> {Font table}
* @param <usOffset> {Offset of font base start address}
* @param <usLength> {Number of font}
* @param <ucPar> {normal font or compress font}
* @return {none}
*
*/
#if (_HARDWARE_LOAD_FONT != _ON)
void CScalerLoadFont(BYTE code *pArray, WORD usOffset, WORD usLength, BYTE ucPar)
{
	if(usLength == 0)
		return;

	usOffset = usOffset * 9;
	usOffset += _OSD_FONT_START_POSITION;
	CScalerLoadFontInAbAddr(pArray, usOffset, usLength, ucPar);

}
#endif
#if 1//(_HARDWARE_LOAD_FONT == _ON)
//--------------------------------------------------
// 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;

    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);

    usOffset = usOffset * 9;
    usOffset += _OSD_FONT_START_POSITION;

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

    MCU_SCA_INF_CTRL_FFF3 = 0x00;
    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;
	MCU_SCA_INF_ADDR_FFF4 = _OSD_DATA_PORT_92;
    for(usOffset=0;usOffset<num;usOffset++)
    {
        *(&MCU_SCA_INF_DATA_FFF5) = *pArray++;
    }

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

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);
}

//--------------------------------------------------
// Description  : Page select for scalar(Only for CR[A1]~CR[DF])
// Input Value  : None
// Output Value : None
//--------------------------------------------------
void CScalerPageSelect(BYTE page)
{
#if(_SCALER_TYPE == _RTD2662)
	CScalerSetByte(_PAGE_SELECT_9F, (page & 0x0F));	
#else
	CScalerSetByte(_PAGE_SELECT_A0, (page & 0x07));
#endif
}

//Field_ByScaler
/*
void CScalerReadByte(BYTE ucAddr, BYTE ucLength, BYTE *pArray, bit bAutoInc)
{
#if(_MCU_TYPE == _REALTEK_RTD2662_EMCU)

    if(bAutoInc)
        *(&MCU_SCA_INF_CTRL_FFF3) = 0x20;
    else
        *(&MCU_SCA_INF_CTRL_FFF3) = 0x00;

    if(ucLength > 0)
    {
        *(&MCU_SCA_INF_ADDR_FFF4) = ucAddr;

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

        }while(--ucLength);

    }

#else

	if(ucLength > 0)
    {
#if(_HOST_INTERFACE == _PARALLEL_PORT)
    CLRSCALERSCSB();
    SETSCALERSDIO0((bit)(ucAddr & 0x01));
    SETSCALERSDIO1((bit)(ucAddr & 0x02));
    SETSCALERSDIO2((bit)(ucAddr & 0x04));
    SETSCALERSDIO3((bit)(ucAddr & 0x08));
    CLRSCALERSCLK();
    SETSCALERSDIO0((bit)(ucAddr & 0x10));
    SETSCALERSDIO1((bit)(ucAddr & 0x20));
    SETSCALERSDIO2((bit)(ucAddr & 0x40));
    SETSCALERSDIO3((bit)(ucAddr & 0x80));
    SETSCALERSCLK();
    SETSCALERSDIO0(_READ);
    SETSCALERSDIO1(bAutoInc);
    CLRSCALERSCLK();
    SETSCALERSDIO0(_HIGH);
    SETSCALERSDIO1(_HIGH);
    SETSCALERSDIO2(_HIGH);
    SETSCALERSDIO3(_HIGH);
#elif(_HOST_INTERFACE == _SERIAL_PORT)
    CLRSCALERSCSB();
    CScalerSendByte(ucAddr);
    SETSCALERSDIO3(_READ);
    CLRSCALERSCLK();
    SETSCALERSDIO3(bAutoInc);
    SETSCALERSCLK();
    SETSCALERSDIO3(_HIGH);
#endif
       	do
       	{
       		*pArray++ = CScalerGetByte();
       	}while(--ucLength);
       	CScalerSendReadStop();
    }
	
#endif	
}
*/