irda.c

支持三星原产的S3C24A0开发板

		*IrDA_RXBUFFER++=0;
	IrDA_RXBUFFER=(unsigned char *)MemoryRx;	
	// Initialize RX Data -----------------END

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

	IrDA_RxCount = 0;
	IrDA_RxWrPnt = 0;
	IrDA_RxRdPnt = 0;
	IrDA_DONE = 1;

	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

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

	while(IrDA_DONE);

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

//==============================================================================
// IrDA Tx ISR
#if 0
void __irq Irda_Int_Tx()
{
	U8 status=0;
	U8 LeftOver = 0;
	U8 ToBeFilled = 0;
	U32 i =0;
	U8 size_FIFO = 0;
	
	// Mast interrupt Pending bit of IrDA
	rINTSUBMSK |= BIT_SUB_IrDA;		// Mask IrDA sub-pending bit
	rINTMSK    |= BIT_IrDA_MSTICK;	// Mask IrDA pending bit

	// Clear interrupt pending bit of IrDA
	rSUBSRCPND = BIT_SUB_IrDA;
	ClearPending(BIT_IrDA_MSTICK);

	status = (U8)rIrDA_IIR;			// Read IIR(Interrupt Identification Register) of IrDA
//	Uart_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;
		}

//		Uart_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
	{
		Uart_Printf("Tx Underrun error!! \n");
		IrDA_CKBUFFER  = (unsigned char *)MemoryCk; 
		IrDA_CKBUFFER1 = (unsigned char *)MemoryCk1;	
		for(i=0; i<IrDA_TxCnt ; i++)
			Uart_Printf("[D:%3d, N:%3d] ", *IrDA_CKBUFFER++, *IrDA_CKBUFFER1++);
	}

	// Unmast interrupt Pending bit of IrDA
	rINTSUBMSK &= ~BIT_SUB_IrDA;	// Unmask IrDA sub-pending bit
	rINTMSK    &= ~BIT_IrDA_MSTICK;	// Unmask IrDA pending bit
}

#else

void __irq Irda_Int_Tx()
{
	U8 status=0;
	U8 i =0;
	
	// Mast interrupt Pending bit of IrDA
	rINTSUBMSK |= BIT_SUB_IrDA;		// Mask IrDA sub-pending bit
	rINTMSK    |= BIT_IrDA_MSTICK;	// Mask IrDA pending bit

	// Clear interrupt pending bit of IrDA
	rSUBSRCPND = BIT_SUB_IrDA;
	ClearPending(BIT_IrDA_MSTICK);

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

	if(status & 0x2) // TX Trigger
	{
		for (i=0;i<16;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 = 0;
		}
		
	}
	else if(status & 0x20) // TX Trigger
		{
			Uart_Printf("Tx Underrun error!! \n");
			IrDA_CKBUFFER  = (unsigned char *)MemoryCk; 
			IrDA_CKBUFFER1 = (unsigned char *)MemoryCk1;	
			for(i=0; i<IrDA_TxCnt ; i++)
				Uart_Printf("[D:%3d, N:%3d] ", *IrDA_CKBUFFER++, *IrDA_CKBUFFER1++);
		}

	// Unmast interrupt Pending bit of IrDA
	rINTSUBMSK &= ~BIT_SUB_IrDA;	// Unmask IrDA sub-pending bit
	rINTMSK    &= ~BIT_IrDA_MSTICK;	// Unmask IrDA pending bit
}

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

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

	Uart_Printf("Data length to transmit (multiple of %d): ",IrDA_TxBUFLEN);
	IrDA_TxCnt = 0;
	IrDA_TxNum = Uart_GetIntNum(); //data length

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

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

	ClearPending(BIT_IrDA_MSTICK);	// Clear IrDA Int Pending
	rSUBSRCPND = BIT_SUB_IrDA;

	rINTSUBMSK &= ~(BIT_SUB_IrDA);		// Unmask IrDA sub-pending bit
	rINTMSK    &= ~(BIT_IrDA_MSTICK);	// Unmask IrDA pending bit

	// Initialize Check Data ----------------START
	IrDA_CKBUFFER=(unsigned char *)MemoryCk;
	for (i=0; i<IrDA_BUFLEN; 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_BUFLEN; i++) {
		*IrDA_CKBUFFER1++ = 0;
	}
	IrDA_CKBUFFER1 = (unsigned char *)MemoryCk1;
	// Initialize Check Data -----------------END

	IrDA_TxDone = 1;

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

	while(IrDA_TxDone);

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

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

	Uart_Printf("\t");
	for(i=0; i<IrDA_TxNum ; i++)
	{
		Uart_Printf("[D:%3d] ", *IrDA_CKBUFFER++);
		if(!((i+1)%64)) Uart_Printf("\n");
		if(!((i+1)%8)) Uart_Printf("\n\t");
	}

	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);
		while (l--) *bHead++ = *rxData++;
		IrDA_DONE = 0;
		Uart_Printf("IrDA DMA0(Rx) Done.....\n");
		rINTSUBMSK &= ~BIT_SUB_DMA0;
	}

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

void Init_Irda_Dma_Rx(void)
{
	// DMA3 IrDA Rx init 
	rDISRC0=(unsigned)0x41800020;	//Address of RxBUF Register
	rDISRCC0=(0<<1)|(1);		//AHB(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)|(7<<24)|(1<<23)|(0<<22)|(0<<20)|(IrDA_RxBUFLEN);
	//demand, sync HCLK, TC int, single transfer, whole service, IrDA, H/W request, 
	//auto-reload, byte, transfer count = IrDA_RxBUFLEN
}

void Test_Irda_Fifo_Dma_Rx(int MODE,int PREAMBLE,int STARTFLAG,int RXFL,int RXTRIG)
{
	int cnt[255], busy[255], dst[255], precnt = 0;
	int i = 0;
		
	unsigned char c;

	// Initialize Check Data ----------------START
	IrDA_RXBUFFER=(unsigned char *)MemoryRx;
	bHead=(unsigned char *)MemoryCk;
	bTail=(unsigned char *)MemoryCk;

	// Initialize RX DMA -----------------START
	pISR_DMA=(unsigned)Irda_Dma_Done;
	Init_Irda_Dma_Rx();
	ClearPending(BIT_DMA);
	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); // Unmask DMA done INT
	rINTSUBMSK=~(BIT_SUB_DMA0); // Unmask DMA done INT	

	IrDA_DONE = 1;	

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

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

	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)0x41800020;	//Address of IrDA_RBR Register
	rDIDSTC1=(0<<1)|(1);		//AHB(IrDA), fix
	rDCON1=(0<<31)|(1<<30)|(1<<29)|(0<<28)|(0<<27)|(7<<24)|(1<<23)|(1<<22)|(0<<20)|(IrDA_BUFLEN);
	//demand, sync HCLK, TC int, unit transfer, single tx, single service, IrDA, H/W request, 
	//off-reload, byte, IrDA_BUFLEN
}

void Test_Irda_Fifo_Dma_Tx(int MODE,int PREAMBLE,int STARTFLAG,int TXFL,int TXTRIG)
{
	int cnt, precnt;
	
	// Initialize TX Data ----------------START
	unsigned char c;
	IrDA_TXBUFFER=(unsigned char *)MemoryTx;
	for(c=1;c<=IrDA_BUFLEN;c++)
		*IrDA_TXBUFFER++=c;
	*IrDA_TXBUFFER=0;
	IrDA_TXBUFFER=(unsigned char *)MemoryTx;
	// Initialize TX Data -----------------END

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

	Uart_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)|(0); 	//run, DMA1 channel on, no-sw trigger 
	rINTMSK=~(BIT_DMA); // Unmask DMA done INT	
	rINTSUBMSK=~(BIT_SUB_DMA1);

	precnt = 0;
	cnt = 0;
	while(IrDA_DONE)
	{
		cnt = rDSTAT1&0xfffff;
		if (precnt != cnt)
	 	{
			Uart_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
	Uart_Printf("TEST_IrDA_FIFO_DMA_TX is done\n");	
	
	Uart_Printf("Tx String :\n");
	IrDA_TXBUFFER=(unsigned char *)MemoryTx;	
	for(c=0;c<IrDA_BUFLEN;c++)
		Uart_Printf("%3d ",*IrDA_TXBUFFER++);
}	
// IrDA DMA Test Code ============================================================== [END]


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

	// GPIO port test	
	rGPCON_M|=(1<<14)|(1<<12)|(1<<10);	// GP28~31 output
	rGPCON_M&=~((1<<15)|(1<<13)|(1<<11));	// GP28~31 output
	rGPPU&=~(0x7<<16); //Uart port pull-up

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

	IrDA_Port_Return();
}       


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;	
	Uart_Printf("IrDA Polling Rx!!!!\n");
	// Initialize RX Buffer-----------------END

	IrDA_Port_Init();

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

	
	IrDA_Port_Return();
}