*IrDA_CKBUFFER++=0;
	IrDA_CKBUFFER=(unsigned char *)MemoryCk;
	// Initialize Check Data -----------------END

	IrDA_RxCount = 0;
	IrDA_RxWrPnt = 0;
	IrDA_RxRdPnt = 0;

	rIrDA_CNT |=(1<<6);
	rIrDA_IER = (1<<7)|(1<<6)|(1<<3)|(1<<0);// LastByteToRx, Err Indication, RxOverRun, Rx Threshold
	rIrDA_CNF = (1); // Enable Interrupt

	printf("IrDA_FCR = %x\n", (char)rIrDA_FCR);

	i = 0;
	printf("\t");
	while(1)
	{
		if (IrDA_RxWrPnt > IrDA_RxRdPnt) {
			printf("[D:%3d] ",*(IrDA_RXBUFFER+IrDA_RxRdPnt));
			IrDA_RxRdPnt++;
			if(!((i+1)%64)) printf("\n");
			if(!((i+1)%8)) printf("\n\t");
			i++;
		}
		if (Uart_GetKey() == '\r') break;
	}
}

//==============================================================================
// IrDA Tx ISR
#if 0
void __irq Irda_Int_Tx()
{
	unsigned char status=0;
	unsigned char LeftOver = 0;
	unsigned char ToBeFilled = 0;
	unsigned int i =0;
	unsigned char size_FIFO = 0;
	
	// Mast interrupt Pending bit of IrDA
	rINTMSK    |= BIT_IrDA;	// Mask IrDA pending bit

	// Clear interrupt pending bit of IrDA
	ClearPending(BIT_IrDA);

	status = (unsigned char)rIrDA_IIR;			// Read IIR(Interrupt Identification Register) of IrDA
//	printf("IrDA IIR:0x%x\n", status);

	if(status & 0x2) // TX Trigger
	{
		//
		// BY DW-K :
		// Check How many bytes were left in the FIFO and determine how many bytes
		// were needed to be put into the FIFO.
		//
		LeftOver = rIrDA_TXNO;
		if(IrDA_FIFOSIZE==1) {	// 64 bytes sized fifo.		
			ToBeFilled = 63 - LeftOver;
			size_FIFO = 63;
		} else {				// 16 bytes sized fifo.
			ToBeFilled = 15 - LeftOver;
			size_FIFO = 15;
		}

//		printf("\tFIR>%d\n", ToBeFilled);

		while ((LeftOver < size_FIFO) && (IrDA_TxCnt < IrDA_TxNum)) { 
//		for (i=0;i<ToBeFilled;i++) {
			rIrDA_RBR = cData;
			*IrDA_CKBUFFER++ = cData++; // for debugging
			*IrDA_CKBUFFER1++ = rIrDA_TXNO; // for debugging
			IrDA_TxCnt++;
			LeftOver = rIrDA_TXNO;
		}

		if (IrDA_TxNum <= IrDA_TxCnt) {
			rIrDA_IER &= ~(1<<1);
			IrDA_TxDone = 0;
		}
	}
	else if(status & 0x20) // TX Trigger
	{
		printf("Tx Underrun error!! \n");
		IrDA_CKBUFFER  = (unsigned char *)MemoryCk; 
		IrDA_CKBUFFER1 = (unsigned char *)MemoryCk1;	
		for(i=0; i<IrDA_TxCnt ; i++)
			printf("[D:%3d, N:%3d] ", *IrDA_CKBUFFER++, *IrDA_CKBUFFER1++);
	}

	// Unmast interrupt Pending bit of IrDA
	rINTMSK    &= ~BIT_IrDA;	// Unmask IrDA pending bit
}

#else

void __irq Irda_Int_Tx()
{
	unsigned char status=0;
	unsigned char i =0;
	
	// Mast interrupt Pending bit of IrDA
	rINTMSK |= BIT_IrDA;	// Mask IrDA pending bit

	// Clear interrupt pending bit of IrDA
	ClearPending(BIT_IrDA);

	status = (unsigned char)rIrDA_IIR;			// Read IIR(Interrupt Identification Register) of IrDA
	//printf("IrDA IIR:0x%x\n", status);

	if(status & 0x2) // TX Trigger
	{
		for (i=0;i<IrDA_TxBUFLEN;i++)
		{
			rIrDA_RBR = cData;
			*IrDA_CKBUFFER++ = cData++;
		}

		IrDA_TxCnt += IrDA_TxBUFLEN;
		//IrDA_TxCnt +=IrDA_TxNum;
		if (IrDA_TxNum <= IrDA_TxCnt) 
		{
			rIrDA_IER &= ~(1<<1);
			IrDA_TxDone = 1;
		}
		
	}
	if(status & 0x20) // TX Trigger
	{
		printf("Tx Underrun error!! \n");
//		IrDA_CKBUFFER  = (unsigned char *)MemoryCk; 
//		IrDA_CKBUFFER1 = (unsigned char *)MemoryCk1;	
//		for(i=0; i<IrDA_TxCnt ; i++)
//			printf("[D:%3d, N:%3d] ", *IrDA_CKBUFFER++, *IrDA_CKBUFFER1++);
	}

	// Unmast interrupt Pending bit of IrDA
	rINTMSK    &= ~BIT_IrDA;	// Unmask IrDA pending bit
}

#endif


void Test_Irda_Fifo_Int_Tx(int MODE,int PREAMBLE,int STARTFLAG,int TXFL,int TXTRIG)
{
	int	i;

	//
	// BY DW-K:
	// Get Bytes count for Tx from USER.
	//

	printf("Data length to transmit (multiple of %d): ",IrDA_TxBUFLEN);
	IrDA_TxCnt = 0;
	IrDA_TxNum = GetIntNum();
	if (IrDA_TxNum == -1) IrDA_TxNum = 16; //data length

	// Initilize IrDA with the FRAME SIZE given by user.
	Init_Irda(MODE, PREAMBLE, STARTFLAG, TXFL, TXTRIG);

	// Register IrDA ISR
	pISR_IrDA = (unsigned)Irda_Int_Tx;

	ClearPending(BIT_IrDA);	// Clear IrDA Int Pending

	rINTMSK &= ~(BIT_IrDA);	// Unmask IrDA pending bit

	// Initialize Check Data ----------------START
	IrDA_CKBUFFER=(unsigned char *)MemoryCk;
	for (i=0; i<IrDA_TxNum; i++) {
		*IrDA_CKBUFFER++ = 0;
	}
	IrDA_CKBUFFER=(unsigned char *)MemoryCk;
	// Initialize Check Data -----------------END

	// Initialize Check Data ----------------START
	IrDA_CKBUFFER1=(unsigned char *)MemoryCk1;
	for (i=0; i<IrDA_TxNum; i++) {
		*IrDA_CKBUFFER1++ = 0;
	}
	IrDA_CKBUFFER1 = (unsigned char *)MemoryCk1;
	// Initialize Check Data -----------------END

	IrDA_TxDone = 0;

	rIrDA_CNT |=(IrDA_TxINTEnb<<7)|(IrDA_RxINTEnb<<6);
	rIrDA_IER  = 0xff;				// Enable all interrpt of IrDA
	rIrDA_CNF  |= (1); // Enable Interrupt 

	while(!IrDA_TxDone);

	printf("Wait until Tx buffer is empty\n");
	while(!(rIrDA_LSR & 0x80));			//Check Tx FIFO empty
	printf("Tx buffer is empty!!, Tx Done!!\n");

	printf("ISR count=%d\n",TxISR_cnt);
	printf("[Tx String :\n");
	IrDA_CKBUFFER  = (unsigned char *)MemoryCk;	
	IrDA_CKBUFFER1 = (unsigned char *)MemoryCk1;	

	printf("\t");
	for(i=0; i<IrDA_TxNum ; i++)
	{
		printf("[D:%3d] ", *IrDA_CKBUFFER++);
		if(!((i+1)%64)) printf("\n");
		if(!((i+1)%8)) printf("\n\t");
	}
	printf("\n");
	rIrDA_IER  = 0x00;				// Disable all interrpt of IrDA
	rIrDA_CNF  &= ~(1);				// Disable Interrupt 
}	
// IrDA Interrupt Test Code end============================================================[END]


// IrDA DMA Test Code Start=============================================================[START]
void __irq Irda_Dma_Done()
{
	int l = IrDA_RxBUFLEN;
	unsigned char *rxData = (unsigned char *)MemoryRx;
	
	rINTSUBMSK|=(BIT_SUB_DMA0|BIT_SUB_DMA1|BIT_SUB_DMA2|BIT_SUB_DMA3);	// Just for the safety	
	
	if(rSUBSRCPND&BIT_SUB_DMA0) // Rx
	{
		rSUBSRCPND = BIT_SUB_DMA0;
		ClearPending(BIT_DMA_SBUS);
		while (l--) *bHead++ = *rxData++;
		IrDA_DONE = 1;
//		printf("IrDA DMA0(Rx) Done.....\n");
		rINTSUBMSK &= ~BIT_SUB_DMA0;
	}

	if(rSUBSRCPND&BIT_SUB_DMA1) // Tx
	{
		rSUBSRCPND = BIT_SUB_DMA1;
		ClearPending(BIT_DMA_SBUS);
		rDMASKTRIG1=0; 	// STOP,DMA3 channel off, no-sw trigger 
		IrDA_DONE=1; // Check Clear the semaphore
		IrDA_TxCnt++;
		rINTSUBMSK &= ~BIT_SUB_DMA1;
//		printf("IrDA DMA1(Tx) Done.....\n");
	}
}

void Init_Irda_Dma_Rx(void)
{
	// DMA3 IrDA Rx init 
	rDISRC0=(unsigned)0x44C00020; //Address of RxBUF Register
	rDISRCC0=(1<<1)|(1); //APB(IrDA), fix
	rDIDST0=(unsigned)MemoryRx; //Address of Memory
	rDIDSTC0=(0<<1)|(0); //AHB(Memory), inc
	rDCON0=(0<<31)|(1<<30)|(1<<29)|(0<<28)|(1<<27)|(0<<22)|(0<<20)|(IrDA_RxBUFLEN);
	//demand, sync HCLK, TC int, single transfer, whole service,
	//auto-reload, byte, transfer count = IrDA_RxBUFLEN
	rDMAREQSEL0=(12<<1)|(1<<0);
	// IrDA, H/W request, 
}

void Test_Irda_Fifo_Dma_Rx(int MODE,int PREAMBLE,int STARTFLAG,int RXFL,int RXTRIG)
{
	// Initialize Check Data ----------------START
	IrDA_RXBUFFER=(unsigned char *)MemoryRx;
	bHead=(unsigned char *)MemoryCk;
	bTail=(unsigned char *)MemoryCk;

	// Initialize RX DMA -----------------START
	pISR_DMA_SBUS=(unsigned)Irda_Dma_Done;
	Init_Irda_Dma_Rx();
	ClearPending(BIT_DMA_SBUS);
	rSUBSRCPND=BIT_SUB_DMA0;
	// Initialize RX DMA  -----------------END

	Init_Irda(MODE, PREAMBLE, STARTFLAG, RXFL, RXTRIG); // Initialize IrDA

	rIrDA_CNF=(1<<3)|(1<<2); // Enable Rx DMA
	rIrDA_CNT|=(1<<6); // Enable RX
	//Delay(5000);
	rDMASKTRIG0=(0<<2)|(1<<1)|(0);    // Run, DMA3 channel on, no-sw trigger 
	rINTMSK=~(BIT_DMA_SBUS); // Unmask DMA done INT
	rINTSUBMSK=~(BIT_SUB_DMA0); // Unmask DMA done INT	

	IrDA_DONE = 0;	

	while(1)
	{
		if (IrDA_DONE) 
		{
			printf("[D:0x%x] ", rDCDST0);
			printf("[H:0x%x] ", bHead);
			printf("[T:0x%x]\n", bTail);

			while (bTail != bHead)
				printf("[D:%3d] ",*bTail++);
			IrDA_DONE=0;
			printf(".\n");
		}
		if (Uart_GetKey() == '\r') break;
	}

	rINTMSK |= (BIT_DMA_SBUS); // Unmask DMA done INT
	rINTSUBMSK |= (BIT_SUB_DMA0); // Unmask DMA done INT	
	rDMASKTRIG0 = 0; 	// Run, DMA3 channel on, no-sw trigger 
}

void Init_Irda_Dma_Tx()
{
	// DMA3 IrDA Tx init 
	rDISRC1=(unsigned)IrDA_TXBUFFER;//Address of Memory
	rDISRCC1=(0<<1)|(0);		//AHB(Memory), inc
	rDIDST1=(unsigned)0x44C00020;	//Address of IrDA_RBR Register
	rDIDSTC1=(1<<1)|(1);		//APB(IrDA), fix
	rDCON1=(0<<31)|(1<<30)|(1<<29)|(0<<28)|(1<<27)|(1<<22)|(0<<20)|(IrDA_TxBUFLEN);
	//demand, sync HCLK, TC int, unit transfer, single tx, single service, 
	//off-reload, byte, IrDA_BUFLEN
	rDMAREQSEL1=(12<<1)|(0<<0);
	// IrDA, S/W request, 
}

void Test_Irda_Fifo_Dma_Tx(int MODE,int PREAMBLE,int STARTFLAG,int TXFL,int TXTRIG)
{
	int cnt, precnt, i;
	unsigned char c = 1;
	
	printf("Data length to transmit (multiple of %d): ",IrDA_TxBUFLEN);
	IrDA_TxNum = GetIntNum(); //data length
	if (IrDA_TxNum == -1) IrDA_TxNum = 16; //data length
	IrDA_TxCnt = 0;
	
	// Initialize TX Data ----------------START
	IrDA_TXBUFFER=(unsigned char *)MemoryTx;
	for(i=0;i<IrDA_TxNum;i++)
		*IrDA_TXBUFFER++ = c==0 ? c=1 : c++;
	*IrDA_TXBUFFER=0;
	IrDA_TXBUFFER=(unsigned char *)MemoryTx;
	// Initialize TX Data -----------------END

	// Initialize TX DMA -----------------START
	pISR_DMA_SBUS=(unsigned)Irda_Dma_Done;
	Init_Irda_Dma_Tx();
	rSUBSRCPND=BIT_SUB_DMA1;
	ClearPending(BIT_DMA_SBUS);
	// Initialize TX DMA  -----------------END

	printf("IrDA DMA Tx!!!!\n");

	Init_Irda(MODE, PREAMBLE, STARTFLAG, TXFL, TXTRIG); // Initialize IrDA

	rIrDA_CNF = (1<<3)|(0<<2); // Enable Tx DMA
	rIrDA_CNT |= (1<<7); // Enable TX
	rDMASKTRIG1 = (0<<2)|(1<<1)|(1); 	//run, DMA1 channel on, sw trigger 
	rINTMSK &= ~(BIT_DMA_SBUS); // Unmask DMA done INT	
	rINTSUBMSK &= ~(BIT_SUB_DMA1);

	IrDA_DONE = 0;	
	precnt = 0;
	cnt = 0;
	while(1)
	{
		if(!IrDA_DONE) continue;

		i = IrDA_TxCnt * IrDA_TxBUFLEN;
		if(i < IrDA_TxNum)
		{
			IrDA_DONE = 0;
			rDISRC1=(unsigned)(IrDA_TXBUFFER+i);//Address of Memory
			rDMASKTRIG1 = (0<<2)|(1<<1)|(1); 	//run, DMA1 channel on, sw trigger 
		}
		else break;				

		// debug
/*		cnt = rDSTAT1&0xfffff;
		if (precnt != cnt)
	 	{
			printf("[DMA count:%d, busy:0x%x, src addr:0x%x, dst addr:0x%x]",cnt,rDSTAT1&0x100000,rDCSRC1,rDCDST1);
			precnt = cnt;
		}
*/	
	}

	while(!(rIrDA_LSR & 0x80)); // Wait until TX FIFO is empty
	rIrDA_CNT&= ~((0<<7)|(0<<6)); // Disable RXTX
	printf("TEST_IrDA_FIFO_DMA_TX is done\n");	
	
	printf("Tx String :\n");
	IrDA_TXBUFFER=(unsigned char *)MemoryTx;	
	for(i=0;i<IrDA_TxNum;i++)
		printf("%3d ",*IrDA_TXBUFFER++);
	rINTMSK |= (BIT_DMA_SBUS); // Unmask DMA done INT	
	rINTSUBMSK |= (BIT_SUB_DMA1);
}	
// IrDA DMA Test Code ============================================================== [END]


// added by junon
void Test_IrDA_GPIO(void)
{
	int i;
	
	SetIrdaPort();

	// GPIO port test	
	rGPHCON &= ~(0x3f<<18);	// GP28~31 output
	rGPHCON |= (0x15<<18);	// GP28~31 output
	rGPHPU &= ~(0x7<<9); 	//Uart port pull-up

	printf("Press Any key...GP16~18 will be triggered... if you want to exit, press Enter key");
	while(getchar() != '\r') 
//		rGPDAT &=~(0xf<<28);
	{	
		i++;
		if ( (i%2) == 0 )	
			rGPHDAT |= (0x7<<9);
		else 
			rGPHDAT &=~(0x7<<9);
	}

	ReturnIrdaPort();
}       


void Test_IrDA_Polling(void)
{
	// Initialize RX Buffer---------------START
	unsigned char c;
	IrDA_RXBUFFER=(unsigned char *)MemoryRx;
	for(c=0;c<IrDA_BUFLEN;c++)
		*IrDA_RXBUFFER++=0;
	*IrDA_RXBUFFER=0;
	IrDA_RXBUFFER=(unsigned char *)MemoryRx;	
	printf("IrDA Polling Rx!!!!\n");
	// Initialize RX Buffer-----------------END

	SetIrdaPort();

	Init_Irda(MODE_VALUE, PREAMBLE_VALUE, STARTFLAG_VALUE, RXFL_VALUE, RXTR_VALUE);
	
	ReturnIrdaPort();
}