//----------------------------------------------------------------------------------------------------
// ID Code      : Video.c No.0002
// Update Note  :
//
//----------------------------------------------------------------------------------------------------

#define __UART__

#include "Core\Header\Include.h"

#if(_DEBUG_TOOL == _RS232)

#if _HDCP_WR_BY_RS232
	WORD addr;
#endif

#if (_DEBUG_Printf_OUTPUT_CONTROL == _ON || _HDCP_WR_BY_RS232 == _ON)

//--------------------------------------------------
// Description  : RS-232 initial
// Input Value  : None
// Output Value : None
//--------------------------------------------------
void CUartInitial(void)
{
	EA = 0;  	// Disable all of 8051 interrupt

	// Initialize SBuf to zero
	SBUF = 0x00;

	// Set to 8051 UART mode 1, refer to Page 2-43
	SCON = 0x50;

	ES = 1; // Enable UART's interrupt
	PS = 1; // Change UART's interrupt to high priority

	// Set the baudrate refer to Timer2, Page 2-37
	T2CON = 0x34;


	//RCAP2L = 0xD4;	//0FFh , 0D4h	//19200
	//RCAP2H = 0xFF;	//0FFh , 0D4h	//19200
#if(_SPEED_UP_FLASH==_ENABLE)
	RCAP2L = 0xCF;		//Flash: 48M; MCU:24M; BaudRate=19200 
	RCAP2H = 0xFF;
#else
	RCAP2L = 0xD4;	//0FFh , 0D4h	//19200
	RCAP2H = 0xFF;	//0FFh , 0D4h	//19200
#endif

	EA = 1;  // Enable 8051 interrupt
}

//-------------------------------------------------------------------------------------------------------------------
//	Uart Main Loop
//-------------------------------------------------------------------------------------------------------------------

////////////////////////////////////////////////////////////////////
//    NEW RS232 COMMAND
//
//    1. Enter Deug Mode	:  0x10,0x01,0x02,0x03,0x04
//    2. Exit Debug  Mode	:  0x11,0x04,0x03,0x02,0x01
//    3. Read RTD2620		:  0x20,Address,Count,Inc
//    4. Read I2C			:  0x21,Slave Address,Address,Count
//    5. Write RTD2620		:  0x30,Address,Data
//    6. Write I2C			:  0x31,Slave Address,Address,Data
//    7. Read Tuner   :  0x24,Slave Address
//    8. Write Tuner  :  0x34,Slave Address,Divider UINT8 1,Divider UINT8 2,Control UINT8,Bandswitch UINT8,Auxiliary UINT8

#if _HDCP_WR_BY_RS232
void CUartTransferChr(unsigned char ucvalue,unsigned char * uctemp)
{

	uctemp[0]=ucvalue/16;
	if(uctemp[0]>9)
	{
		uctemp[0]=(uctemp[0]-10)+0x41;
	}
	else
	{
		uctemp[0]=uctemp[0]+0x30;
	}
	
	uctemp[1]=ucvalue%16;
	if(uctemp[1]>9)
	{
		uctemp[1]=(uctemp[1]-10)+0x41;
	}
	else
	{
		uctemp[1]=uctemp[1]+0x30;
	}
	
}
#endif	//#if _HDCP_WR_BY_RS232

//--------------------------------------------------
// Description  : Uart handler
// Input Value  : None
// Output Value : None
//--------------------------------------------------

void CUartHandler(void)
{
	#if(_EXTERNAL_FLASH_TABLE == _ON)
	UINT32 xdata FlashAddr=0;
	UINT8 xdata FlashIndex;
	UINT8 xdata FlashData[16];
	#endif
	#if _HDCP_WR_BY_RS232
	BYTE data pUartChtData[2];
	BYTE i;
	BYTE pDataRd[14];
	#endif

	if (fDebugModeEnable == 0)
	{
		if (pUartData[0] == UartCMD_DebugModeEnter)
			if (pUartData[1] == 0x01)
				if (pUartData[2] == 0x02)
					if (pUartData[3] == 0x03)
						if (pUartData[4] == 0x04)
						{
							fDebugModeEnable = 1;
							CUartPutCharToScr(0x10,0);	// willy 050810 for sync RS232
						}
		if (pUartData[0] == (UartCMD_DebugModeExit))
			CUartPutCharToScr(0x11,0);	// willy 050810 for sync RS232
	}
	while (fDebugModeEnable == 1)
	{
#if((_MCU_TYPE == _REALTEK_RTD2662_EMCU) && (_DEBUG_TOOL == _RS232)) //fjyang
#if _DEBUG_HDCP_WR_STATUS
		if (ucRtd2662IspFlag==0)
			LED_Message(_LED_MSG_FLASH_GREEN);
#endif	//#if _DEBUG_HDCP_WR_STATUS
#endif	//#if((_MCU_TYPE == _REALTEK_RTD2662_EMCU) && (_DEBUG_TOOL == _RS232)) //fjyang

		if (fTest == 1)
		{
			fTest = 0;

			if (pUartData[0] == UartCMD_DebugModeExit)
				if (pUartData[1] == 0x04)
					if (pUartData[2] == 0x03)
						if (pUartData[3] == 0x02)
							if (pUartData[4] == 0x01)
							{
								fDebugModeEnable = 0;
								CUartPutCharToScr(0x11,0);	// willy 050810 for sync RS232
								break;
							}
			//****************debug mode main loop Start
			switch (pUartData[0])
			{
				case UartCMD_CScalerRead:
					if (!pUartData[3])
    						CScalerRead(pUartData[1], pUartData[2], pData, _AUTOINC);
					else
						CScalerRead(pUartData[1], pUartData[2], pData, _NON_AUTOINC);
					break;

				case UartCMD_I2CRead:
					if (pUartData[1]<0x40 ||  pUartData[1]>0x4F)
					{
						break;
					}
					if (pUartData[2]>=0xa0)	//page date is from 0xA0
					{
						CScalerPageSelect(pUartData[1]&0x0f); 
					}
					CScalerRead( pUartData[2], pUartData[3], pData, _AUTOINC);
					break;

				case UartCMD_CScalerWrite:
					pData[0] = pUartData[2];
					CScalerWrite(pUartData[1], 1, pData, _NON_AUTOINC);
					CUartPutCharToScr(0x30,0);	// willy 050810 for sync RS232
					break;

				case UartCMD_I2CWrite:
					if (pUartData[1]<0x40 ||  pUartData[1]>0x4F)
					{
						break;
					}
					if (pUartData[2]>=0xa0)	//page date is from 0xA0
					{
						CScalerPageSelect(pUartData[1]&0x0f); 
					}
					CScalerSetByte(pUartData[2], pUartData[3]); 
					CUartPutCharToScr(0x31,0);	// willy 050810 for sync RS232
#if _HDCP_WR_BY_RS232
				case UartCMD_FlashHdcpRead:
	#if _SPI_FLASH_EN25F40
						addr = pUartData[1];
						addr = addr<<8;
						addr = addr+pUartData[2];
						//20090416, add
						if (pUartData[3]>8)
							pUartData[3]=8;
						
						if (addr<128)
						{
							CEepromFlashLoadData(_EEPROM_FLASH_HDCP_KEY0_ADDRESS, addr, addr+pUartData[3], pDataRd);
						}
						else if (addr<256)
						{
							CEepromFlashLoadData(_EEPROM_FLASH_HDCP_KEY1_ADDRESS, (WORD)addr-128, (WORD)addr-128+pUartData[3], pDataRd);
						}
						else if (addr<384)
						{
							CEepromFlashLoadData(_EEPROM_FLASH_HDCP_KEY2_ADDRESS, (WORD)addr-256, (WORD)addr-256+pUartData[3], pDataRd);
						}
	#else
						addr = pUartData[1];
						addr = addr<<8;
						addr = addr+pUartData[2];

						//20090416, add
						if (pUartData[3]>8)
							pUartData[3]=8;

						for (i=0;i<pUartData[3];i++)
							pDataRd[i]=0;
						CEepromReadFlash(addr, pUartData[3], pDataRd);
	#endif
					break;

				case UartCMD_FlashHdcpWrite:
	#if _SPI_FLASH_EN25F40
					addr = pUartData[1];
					addr = addr<<8;
					addr = addr+pUartData[2];

					if (addr == 0)
						ucHdcpKeyCnt = 0;	//initial byte counter

					for (i=0; i<pUartData[3]; i++)
					{
						MCU_DDCRAM_VGA[ucHdcpKeyCnt++] = pUartData[4+i];
					}

					if (addr==128-8 ||addr==256-8 ||addr==384-8)
					{
						ucHdcpKeyCnt = 0;	//ready for next sector bytes counter
						if (addr==128-8)
						{
							CEepromFlashSaveData(_EEPROM_FLASH_HDCP_KEY0_ADDRESS, 0x00, 128, MCU_DDCRAM_VGA);
						}
						else if (addr==256-8)
						{
							CEepromFlashSaveData(_EEPROM_FLASH_HDCP_KEY1_ADDRESS, 0x00, 128, MCU_DDCRAM_VGA);
						}
						else if (addr==384-8)
						{
							CEepromFlashSaveData(_EEPROM_FLASH_HDCP_KEY2_ADDRESS, 0x00, 128, MCU_DDCRAM_VGA);
						}
					}
	#else
					addr = pUartData[1];
					addr = addr<<8;
					addr = addr+pUartData[2];

					CEepromWriteFlash(addr, pUartData[3], &pUartData[4]);
	#endif
					break;
#endif
					break;

			#if _RS232_TUNER// Read/Write Philip_Tuner
				case UartCMD_TunerRead:
					I2CRead(pUartData[1], 0, 1);
					pUartData[2] = 1;	// read count
					break;

				case UartCMD_TunerWrite:
					pData[0] = 6;
					pData[1] = pUartData[2];
					pData[2] = pUartData[3];
					pData[3] = pUartData[4];
					pData[4] = pUartData[5];
					pData[5] = 0x20;
					pData[6] = 0;
					CI2cWriteArray(pUartData[1],pData);
					CUartPutCharToScr(0x34,0);	// willy 050810 for sync RS232
					break;
			#endif//_RS232_TUNER

			#if(_EXTERNAL_FLASH_TABLE == _ON)
				case UartCMD_FlashRead:
			 		FlashAddr = (UINT32)pUartData[1]<<16;
					FlashAddr += (UINT16)pUartData[2]<<8;
					FlashAddr += pUartData[3];
					for (FlashIndex =0;FlashIndex<pUartData[4];FlashIndex++)
						FlashData[FlashIndex]=CEepromFlasReadOneByte(FlashAddr+FlashIndex);
					break;
				/*
				case UartCMD_FlashEraseSector:
					//MCU_THRESHOLD_VALUE_FF0F = 0x88;
					FlashAddr = (UINT32)pUartData[1]<<16;
					FlashAddr += (UINT16)pUartData[2]<<8;
					FlashAddr += pUartData[3];
					CEepromFlashEraseSector(FlashAddr);
					CUartPutCharToScr(0x12,0);
					break;			
				case UartCMD_FlashWrite:
					//MCU_THRESHOLD_VALUE_FF0F = 0x99;
					FlashAddr = (UINT32)pUartData[1]<<16;
					FlashAddr += (UINT16)pUartData[2]<<8;
					FlashAddr += pUartData[3];
					for (FlashIndex=0;FlashIndex<pUartData[4];FlashIndex++)
					{
						CEepromFlashWriteOneByte(FlashAddr+FlashIndex, pUartData[5+FlashIndex]);
					}
					CUartPutCharToScr(0x35,0);
					break;
				*/
			#endif

			}

			//20071015, HDCP key write to Flash 2Mbit
#if _HDCP_WR_BY_RS232
			if (pUartData[0] == (UartCMD_FlashHdcpRead))
			{ //if Read command , Send data to PC
				
				CUartTransferChr(UartCMD_FlashHdcpRead,pUartChtData);
				CUartPutCharToScr(pUartChtData[0],0);
				CUartPutCharToScr(pUartChtData[1],0);

				CUartTransferChr(pUartData[3],pUartChtData);
				CUartPutCharToScr(pUartChtData[0],0);
				CUartPutCharToScr(pUartChtData[1],0);

				for (i = 0;i < pUartData[3];i++)//send data
				{
					CUartTransferChr(pDataRd[i],pUartChtData);
					CUartPutCharToScr(pUartChtData[0],0);
					CUartPutCharToScr(pUartChtData[1],0);
				}
					
			}
			else if (pUartData[0] == (UartCMD_FlashHdcpWrite))
			{
				CUartPutCharToScr(UartCMD_FlashHdcpWrite,0);	// willy 050810 for sync RS232
			}
				
#endif	//#if _HDCP_WR_BY_RS232

			if (pUartData[0] == (UartCMD_DebugModeEnter))
				CUartPutCharToScr(0x10,0);	// willy 050810 for sync RS232

			if((pUartData[0] & 0xF0) == UartCMD_CScalerRead)
			{ //if Read command , Send data to PC
				if(pUartData[0] == UartCMD_CScalerRead)
					pUartData[3] = pUartData[2];
			#if(_EXTERNAL_FLASH_TABLE == _ON)
				if(pUartData[0] == UartCMD_FlashRead)
					pUartData[3] = pUartData[4]; //count
			#endif

				CUartPutCharToScr(pUartData[3],0);
				#if(_EXTERNAL_FLASH_TABLE == _ON)//yf_zhang 2007-08-03
				if(pUartData[0] != UartCMD_FlashRead){
					for (pUartData[0] = 0;pUartData[0] <= pUartData[3];pUartData[0]++)//send data
						CUartPutCharToScr(pData[pUartData[0]],0);
					}else if(pUartData[0] == UartCMD_FlashRead){
					for(pUartData[0] = 0;pUartData[0] <= pUartData[3];pUartData[0]++)//send data
						CUartPutCharToScr(FlashData[pUartData[0]],0);
				}
				#else
				   	for (pUartData[0] = 0;pUartData[0] <= pUartData[3];pUartData[0]++)//send data
						CUartPutCharToScr(pData[pUartData[0]],0);
				#endif
			}
//***
#if(_SCALER_TYPE==_RTD2662)
			if (pUartData[0] == (UartCMD_I2CRead))
			{
				BYTE i;
				if (pUartData[1]<0x40 ||  pUartData[1]>0x4F)
				{
					return;
				}
				CUartPutCharToScr(pUartData[3],0);
				for (i=0;i<pUartData[3];i++)
				{
					CUartPutCharToScr(pData[i],0);
				}
			}
#endif
//***
		}
   	}

}

#endif	//#if (_DEBUG_Printf_OUTPUT_CONTROL == _ON || _HDCP_WR_BY_RS232 == _ON)

#if (_DEBUG_Printf_OUTPUT_CONTROL == _ON || _HDCP_WR_BY_RS232 == _ON)
// ******************************************************************************** //

#if (_DEBUG_Printf_OUTPUT_CONTROL == _ON)
const unsigned char DebugPrintf(const unsigned char code* pstr,unsigned char value)
{
	unsigned char StrIndex;

	for (StrIndex=0x00; *(pstr+StrIndex)!='\0'; StrIndex++)
    {
		if(*(pstr+StrIndex) == '\n'){
			CUartPutCharToScr('\r',0);
			CUartPutCharToScr(*(pstr+StrIndex),0);
       	}
		else if(*(pstr+StrIndex) == '%'&& *(pstr+StrIndex+1) == 'd'){
			StrIndex++;
			CUartPutCharToScr(value,1);
        }
		else if(*(pstr+StrIndex) == '%'&& *(pstr+StrIndex+1) == 'x'){
			StrIndex++;
			CUartPutCharToScr(value,2);
        }
		else if(*(pstr+StrIndex) == '%'&& *(pstr+StrIndex+1) == 'c'){
			StrIndex++;
			CUartPutCharToScr(value,0);
        }
		else
			CUartPutCharToScr(*(pstr+StrIndex),0);
    }
	return StrIndex;
}

#endif	//#if (_DEBUG_Printf_OUTPUT_CONTROL == _ON)


// ******************************************************************************** //
void CUartPutCharToScr(const UINT8 ch, UINT8 mode)
{
	UINT8 NO1[3],i,time;

	ES = 0;
	if (mode == 0) {
		TI = 0;
		SBUF = ch; // transfer UART
		while (!TI);		// wait buffer completing.
	}
	else if (mode == 1) {	//dec
		NO1[2] = ch / 100;
		NO1[1] = (ch % 100) / 10;
		NO1[0] = (ch % 100) % 10;
		if (NO1[2] != 0)
			time = 3;
		else if (NO1[1] != 0)
			time = 2;
		else
			time = 1;
		for (i = 0; i < time; i++) {
			TI = 0;
			SBUF = NO1[time - i - 1] + '0'; // transfer UART
			while (!TI) ;	// wait buffer completing.
		}
	}
	else if (mode == 2) {	//hex
		NO1[1] = (ch & 0x0F);
		NO1[0] = ((ch >> 4) & 0x0F);
		for (i = 0; i < 2; i++) {
			TI = 0;
			if (NO1[i] > 9)
				SBUF = NO1[i] - 10 + 'A';
			else
				SBUF = NO1[i] + '0';	 	// transfer UART
			while (!TI);					// wait buffer completing.
		}
	}
	ES = 1;
}
#endif	//#if (_DEBUG_Printf_OUTPUT_CONTROL == _ON || _HDCP_WR_BY_RS232 == _ON)



#endif  // End of #if(_DEBUG_TOOL == _RS232)