* DATE          Author          Description
* ===========================================================================
* 2004-04-15	K.M. Ho         This is first time implement
*/
void	PrepareSendBuf(char *sendbuf, int addr, char data_length, char cmd_type)
{
	struct UART_PACK	*tx_pack;
	char				crc_byte;
	char				i;

	tx_pack = (struct UART_PACK *)sendbuf;	//TX struct pointer to sending buffer
	tx_pack->syn1	= SYN_BYTE;			//SYN
	tx_pack->cmd	= cmd_type;			//command
	tx_pack->length	= data_length;		//data length
	tx_pack->reserve=0x00;				//reserve is always 0
//	tx_pack->addr	= addr;
	sendbuf[4]		= (char) (addr    &0x00ff);		//addr low byte
	sendbuf[5]		= (char)((addr>>8)&0x00ff);		//addr high byte
	tx_pack->crc	= 0x00;				//clean CRC
	tx_pack->syn2	= SYN_BYTE;			//put SYN to send buffe

	crc_byte = 0;						//clean CRC check byte
	for (i=0; i<data_length+UART_PACK_SIZE; i++)
		crc_byte ^= sendbuf[i];			//make CRC check byte

	tx_pack->crc  = crc_byte;			//put in CRC byte
}

/**--------------------------------------------------------------------------
* Name          void    UART_ParseFun(void);
*
* Description	Parse the recive buf when the PARSE flag is setting
*				There are
*				ACK			device RX is OK
*				NACK		device RX in not OK, request resend
*				MSGSHOW		device request show message on PC screen
*				DEVICEINF	device respond information
*				MEMRESPOND	device respond memory content of address
*				REGRESPOND				   register
*
* Flow Chart	1. copy RX buffer data to tmp and make CRC check byte
*				2. clean PARSE flag
*				3. is CRC right?	No, send NACK command
*				4. parse COMMAND
*				5. send ACK command if need.
*
* Return
*
* DATE          Author		Description
* ===========================================================================
* 2003-01-22	KM Ho		This is first time implement
* 2003-03-27	KM Ho		Modify RX ACK command process
* 2004-05-19	Eson W.
* 2004-11-17	KMHo		Add EEPROM Read/Write Command
**/

void	UART_ParseFun()
{
	struct UART_PACK	*rx_pack;
	char	crc_byte;
	char	buf_index;
	BYTE	i, send_length;
	BYTE	sendtemp[32];

	buf_index = UART_RxInUse ^ 1;	//chang to Rx complete buffer
									//RX buf is double buffer
	rx_pack = (struct UART_PACK *)Rx_Buf[buf_index];

	crc_byte = 0x00;						//make CRC check byte
	for(i=0; i<Parse_Length; i++)
		crc_byte  ^= Rx_Buf[buf_index][i];

	UARTFlag &= (RX_PARSE^CLEAN_UARTFlag);	//clean parse flag

	if (crc_byte)							//CRC error sent NACK and return
	{
		PrepareSendBuf(sendtemp, 0, 0, NACK);
		UART_SendOut(sendtemp, UART_PACK_SIZE);
		return;
	}

	if (rx_pack->cmd == ACK)		//if ACK command will clean UARTFlag
	{								//				 and return
		UARTFlag &= (TX_WAITACK ^ CLEAN_UARTFlag);	//clean wait ACK
		return;
	}
			//*** ---------------------------------------------------------	***
			//	The Respond data from Byte 16
			//	There are ACK cmd 8Bytes + Respond Cmd 8Bytes+ Respond data
			//*** ---------------------------------------------------------	***
	send_length = 0;
	PrepareSendBuf(sendtemp, 0, 0, ACK);
	switch(rx_pack->cmd)	//parse COMMAND
	{
		case GETDEV:
			for (i=0; i<16; i++)
				sendtemp[i+16] = DEV_Inf[i];	
					//--- Pack the Resopnd Cmd and Data ---
			PrepareSendBuf(&sendtemp[8], rx_pack->addr, 16, DEVICEINF);
			send_length = UART_PACK_SIZE + 16;
			break;

		case MEMRD:
			ExtMemPtr = Rx_Buf[0];
			for (i=0; i<rx_pack->length; i++)
				sendtemp[i+16] = *(ExtMemPtr+rx_pack->addr+i);
					//--- Pack the Resopnd Cmd and Data ---
			PrepareSendBuf(&sendtemp[8], rx_pack->addr, rx_pack->length, MEMRP);
			send_length = UART_PACK_SIZE + rx_pack->length;
			break;
			
		case MEMWR:
			ExtMemPtr = Rx_Buf[0];
			for (i=0; i<rx_pack->length; i++)
				*(ExtMemPtr+rx_pack->addr+i)= Rx_Buf[buf_index][i+8];
			break;	
			
		case REGRD15xx:		
					//--- Pack the Resopnd Cmd and Data ---					
			I2C_Read(L44_WRID, rx_pack->addr, rx_pack->length, &sendtemp[16]);		
			PrepareSendBuf(&sendtemp[8],rx_pack->addr,rx_pack->length,rx_pack->cmd|0x40);
			send_length = UART_PACK_SIZE + rx_pack->length;
			break;
			
		case REGWR15xx:		//Read data from 15xx Reg.
			I2C_WriteByte(L44_WRID, rx_pack->addr, Rx_Buf[buf_index][8]);
			break;
			
		case RDEEPROM:		//Read data from EEPROM
			i = (BYTE)((rx_pack->addr>>7) & 0x000E);	
			I2C_Read(EEPROM_WRID|i, rx_pack->addr, rx_pack->length, &sendtemp[16]);		
			PrepareSendBuf(&sendtemp[8],rx_pack->addr,rx_pack->length,rx_pack->cmd|0x40);
			send_length = UART_PACK_SIZE + rx_pack->length;
			break;
			
		case WREEPROM:		//Write data to EEPROM
			i = (BYTE)((rx_pack->addr>>7) & 0x000E);
			I2C_WriteByte(EEPROM_WRID|i, rx_pack->addr, Rx_Buf[buf_index][8]);
			break;
			
		case RDGAMMA:		//Read 768bytes data from Gamma port and Respond to PC
			if (rx_pack->addr == 0)	
				I2C_WriteByte(L44_WRID, 0x11, 0xF6);	//Enable Gamma correction and access
			
			for (i=0; i<rx_pack->length; i++)				
				sendtemp[i+16] = I2C_ReadByte(L44_WRID, 0x1B);
			PrepareSendBuf(&sendtemp[8],rx_pack->addr,rx_pack->length,rx_pack->cmd|0x40);
			send_length = UART_PACK_SIZE + rx_pack->length;
			
			if (rx_pack->addr >= 0x2F0)	
				I2C_WriteByte(L44_WRID, 0x11, 0xFA);	//disable Gamma correction and access
			break;
			
		case WRGAMMA:		//Write 768bytes data to Gamma port from PC	
			if (rx_pack->addr == 0)
				I2C_WriteByte(L44_WRID, 0x11, 0xF6);	//Enable Gamma correction and access
				
			for (i=0; i<rx_pack->length; i++)	
				I2C_WriteByte(L44_WRID, 0x1B, Rx_Buf[buf_index][8+i]);
				
			if (rx_pack->addr >= 0x2F0)	
				I2C_WriteByte(L44_WRID, 0x11, 0xFA);	//disable Gamma correction and access
			break;
			
					// **********************
					// ***--- Indirect ---***
					// **********************
		case REGRDOSDCtrl:		//respond the OSD Control Reg. from rx_pack->addr
			Read_OSDReg(&sendtemp[16], 0x00, rx_pack->length, rx_pack->addr);
					//--- Pack the Resopnd Cmd and Data ---
			PrepareSendBuf(&sendtemp[8],rx_pack->addr,rx_pack->length,rx_pack->cmd|0x40);
			send_length = UART_PACK_SIZE + rx_pack->length;
			break;
			
		case REGRDOSDCode:		//respond the OSD Code Reg. from rx_pack->addr
			Read_OSDReg(&sendtemp[16], 0x02, rx_pack->length, rx_pack->addr);
					//--- Pack the Resopnd Cmd and Data ---
			PrepareSendBuf(&sendtemp[8],rx_pack->addr,rx_pack->length,rx_pack->cmd|0x40);
			send_length = UART_PACK_SIZE + rx_pack->length;
			break;
			
		case REGRDOSDAttr:		//respond the OSD Attr. Reg. from rx_pack->addr
			Read_OSDReg(&sendtemp[16], 0x03, rx_pack->length, rx_pack->addr);
					//--- Pack the Resopnd Cmd and Data ---
			PrepareSendBuf(&sendtemp[8],rx_pack->addr,rx_pack->length,rx_pack->cmd|0x40);
			send_length = UART_PACK_SIZE + rx_pack->length;
			break;

		case REGRDTVDecoder:	//respond the TV Decoder Reg. from rx_pack->addr
			for (i=0; i<rx_pack->length; i++)
				sendtemp[i+16] = CVD1_ReadWrite(0x00, rx_pack->addr+i, 0x00);
//			I2C_Read(TVP5146_WRID, rx_pack->addr, rx_pack->length, &sendtemp[16]);
					//--- Pack the Resopnd Cmd and Data ---
			PrepareSendBuf(&sendtemp[8], rx_pack->addr, rx_pack->length, REGRPTVDecoder);
			send_length = UART_PACK_SIZE + rx_pack->length;
			break;
/*
		case REGRDTVTuner:
			for (i=0; i<(rx_pack->length); i++)
			{
				sendtemp[i+UART_PACK_SIZE]
							=	rd_HXT5G01A();
			}
			PrepareSendBuf(sendtemp, 0, 0, ACK);
			PrepareSendBuf(&sendtemp[8], rx_pack->addr, rx_pack->length, REGRPTVTuner);
			UART_SendOut(sendtemp, 16+rx_pack->length);
			break;
*/
		case REGWROSDCtrl:		//write data to OSD Control Reg.
			Write_OSDReg(&Rx_Buf[buf_index][8], 0x00, 0x01, rx_pack->addr);
			break;
		case REGWROSDCode:		//write data to OSD Code Reg.
			Write_OSDReg(&Rx_Buf[buf_index][8], 0x02, 0x01, rx_pack->addr);
			break;		
		case REGWROSDAttr:		//write data to OSD Attr. Reg.
			Write_OSDReg(&Rx_Buf[buf_index][8], 0x03, 0x01, rx_pack->addr);
			break;
			
		case REGWRTVDecoder:	//write data to TV Decoder Reg.
			CVD1_ReadWrite(0x01, rx_pack->addr, Rx_Buf[buf_index][8]);
			break;
/*
		case REGWRTVTuner:
			PrepareSendBuf(sendtemp, 0, 0, ACK);
			UART_SendOut( sendtemp, UART_PACK_SIZE);
			wr_HXT5G01A(1);							// int i--> index
			P1=~(REGWRTVTuner);
			break;
*/
		case NACK:
			UARTFlag |= TX_FLAG;			//set flag for send
/*
			for (i=0; i<ReTx_Length; i++)	//copy send data to TX buffer
				Tx_Buf[i] = ReTx_Buf[i];
			Tx_Length = ReTx_Length;		//copy sending data length
*/
			Tx_Index = 1;
			SBUF=Tx_Buf[0];
			return;

		default:					//not define command will reset flag
			UARTFlag = 0;
			Rx_Index = 0;
			P1=~(0xFF);
			return;
	}	
	UART_SendOut(sendtemp, UART_PACK_SIZE+send_length);	
}