irda.c

三星s3c2460开发板完整功能测试代码

//===================================================================
// NAME		: irda.c	
// DESC		: ver 1.1 compatible test module
// History	: 2003.06.25 edited by junon jeon from SMDK5410 test code
//          : 2003.10.09 Edited to verify IrDA core.by Minsoo, Lim
//          : 2003.10.31 Edited by Junon (DMA rx)
//===================================================================

#include <string.h>
#include <stdlib.h>
#include "2460addr.h"
#include "2460lib.h"
#include "option.h"
#include "irda.h"

#define MemoryRx	(_NONCACHE_STARTADDRESS+0x1000)
#define MemoryTx	(_NONCACHE_STARTADDRESS+0x2000)
#define MemoryCk	(_NONCACHE_STARTADDRESS+0x3000)
#define MemoryCk1	(_NONCACHE_STARTADDRESS+0x4000)

#define IrDA_BUFLEN		16		//Maximum about 255
#define IrDA_TxBUFLEN	16		//Maximum about 64
#define IrDA_RxBUFLEN	16		//Maximum about 64

#define IrDA_FIFOSIZE   1		// 0 : 16, 1 : 64 bytes
#define IrDA_FIFOENB	 1		// 1 : Enbale IrDA Tx/Rx FIFO

//====================================================================
// IrDA Contol Register (IrDA_CNT)
// This value only valid MIR mode.
#define	IrDA_TxINTEnb	1	// 1 : Enable Tx Interrupt
#define	IrDA_RxINTEnb	0	// 1 : Enable Rx Interrupt for loop test
#define	IrDA_LOOP_MODE	0	// 0 : Normal, 1 : Loop mode for core test
#define	MIR_HALF_MODE	0	// 0 : MIR,    1 : MIR-Half
#define	IrDA_SEND_SIP	0	// 1 : Send SIP pulse

//====================================================================
// IrDA Mode Definition Register (IrDA_MDR)

// -----------------------
// IrDA Test Configuration
// -----------------------
#define MODE_VALUE		0
// mode
// MODE			FIR|MIR mode
// 0			FIR mode
// 1			MIR mode

#define	PREAMBLE_VALUE		0
// number of preembles (FIR mode only)
// PREAMBLE		number of preambles
// 00b			16
// 01b			04
// 10b			08
// 11b			32

#define	STARTFLAG_VALUE		3
// number of start flags (MIR mode only)
// START_FLAG	number of start flags
// minimum value 3 required !!!

#define	RXFL_VALUE		0x1000
// Number of RX data

#define	RXTR_VALUE		1
// RX FIFO trigger level
// 00b			Reserved
// 01b			04|16
// 10b			08|32
// 11b			14|56

#define	TXFL_VALUE		16
// Number of TX data 

#define	TXTR_VALUE		1
// TX FIFO trigger level
// 00b			Reserved
// 01b			12|48
// 10b			08|32
// 11b			02|08

volatile int IrDA_DONE, IrDA_TxDone, IrDA_RxDone, IrDA_RxCount;
volatile int	IrDA_RxWrPnt, IrDA_RxRdPnt;
unsigned int save_rGPCON, save_rGPUP, save_rSPCON;
volatile unsigned char * IrDA_RXBUFFER;
volatile unsigned char * IrDA_TXBUFFER;
volatile unsigned char * IrDA_CKBUFFER;
volatile unsigned char * IrDA_CKBUFFER1;

unsigned char cData=0;
volatile int	IrDA_TxNum, IrDA_TxCnt;
volatile int RxISR_cnt,TxISR_cnt;

unsigned char *bHead, *bTail;
int tMode;

void * IrDA_func[][2]=
{
	(void *)Test_IrDA_Fifo_Rx,		"IrDA FIFO Rx",
	(void *)Test_IrDA_Fifo_Tx,		"IrDA FIFO Tx",
	0,0
};

void Ch12_IrDA(void)
{
	while(1)
	{
		int i = 0;
  
		printf("\n");
		while(1)
		{	//display menu
			printf("%2d:%s",i,IrDA_func[i][1]);
			i++;
			if((int)(IrDA_func[i][0])==0)
			{
				printf("\n");
				break;
			}
			if((i%4)==0)
				printf("\n");
		}
		
		printf("\nSelect the function to test : ");
		i = GetIntNum();
		printf("\n");
		if(i==-1) break;	 	
		if(i>=0 && (i<(sizeof(IrDA_func)/8)) ) 
		( (void (*)(void)) (IrDA_func[i][0]) )();			
	}
}

void Test_IrDA_Fifo_Rx(void)
{
	SetIrdaPort();
	
	printf("\nSelect transfering mode	1. FIR(D)    2. MIR full  3. MIR half : \n");
	tMode = GetIntNum() - 1;
	if (tMode == -2) tMode = 0; 
	
	printf("IrDA Interrupt Rx Test\n");
	printf("Select control mode : 1. Interrupt(D)    2. DMA\n");

	if (getchar() == '2')
		Test_Irda_Fifo_Dma_Rx(tMode, PREAMBLE_VALUE, STARTFLAG_VALUE, RXFL_VALUE, RXTR_VALUE);
	else
		Test_Irda_Fifo_Int_Rx(tMode, PREAMBLE_VALUE, STARTFLAG_VALUE, RXFL_VALUE, RXTR_VALUE);

	ReturnIrdaPort();
}

void Test_IrDA_Fifo_Tx(void)
{
	SetIrdaPort();

	printf("\nSelect transfering mode	1. FIR(D)    2. MIR full  3. MIR half : \n");
	tMode = GetIntNum() - 1;
	if (tMode == -2) tMode = 0; 
	
	printf("IrDA Interrupt Tx Test\n");
	printf("Select control mode : 1. Interrupt(D)    2. DMA\n");

	if (getchar() == '2')
		Test_Irda_Fifo_Dma_Tx(tMode, PREAMBLE_VALUE, STARTFLAG_VALUE, TXFL_VALUE, TXTR_VALUE);
	else
		Test_Irda_Fifo_Int_Tx(tMode, PREAMBLE_VALUE, STARTFLAG_VALUE, TXFL_VALUE, TXTR_VALUE);

	ReturnIrdaPort();
}

void SetIrdaPort(void)
{
    save_rGPCON = rGPHCON;
    save_rGPUP = rGPHPU;
    save_rSPCON = rSPCON;
    rGPHCON &= ~((3<<22)|(3<<20)|(3<<18)); // Set IrDA_TXD, IrDA_RXD, IrDA_SDBW
    rGPHCON |= (2<<22)|(2<<20)|(2<<18);
    rGPHPU |= (7<<9); // Disable IrDA pullup
    rSPCON |= (1<<2); // select IrDA 1.1 core
    printf("IrDA Port Initialize!!!\n");
}

void ReturnIrdaPort(void)
{
    rGPHCON = save_rGPCON;
    rGPHPU = save_rGPUP;
    rSPCON = save_rSPCON;
}

unsigned char	Init_Irda(int MODE, int PREAMBLE, int STARTFLAG, int RXTXFL, int RXTXTRIG)
// MODE : 010 - MIR mode,  100 - FIR mode	
// PREAMBLE : 00 - 16,  01 - 4,  10 - 8,  11 - 32 preamble data length
// STARTFLAG : 2 ~ 15 start flag
// RXTXFL : 0 ~ 65535 Frame length
// RXTXTRIG : 00 - reserved,  01 - TX(12/48),RX(4/16), 
//					10 - TX(8/32),RX(8/32),  11 - TX(2/8),RX(14/56) [for 16/64byte]
//    				FIFO TRIG level set
{
	int cnt;
	int selFIR = 0;
	int selMIR = 0;
	
	if (MODE != 0)
	{
		selFIR = 1;
		if (MODE == 1)
		{
			selMIR = 0;
			printf(" [MIR full mode]\n");	
		}
		if (MODE == 2)
		{
			selMIR = 1;
			printf(" [MIR half mode]\n");	
		}
	}		
	else 
	{
		selFIR = 4;
		printf(" [FIR mode]\n");
	}

	// IrDA Control Register
	// Tx disable/Rx disable/No Frame abort/SDBW High
	rIrDA_CNT = (IrDA_LOOP_MODE<<5)|(selMIR<<4)|(IrDA_SEND_SIP<<3)|(1);

	// Mode & Transceiver Set Register
	rIrDA_MDR = (1<<4) | (1<<3) | selFIR;	// Sip every frame / HP / Mode 

	printf("rMDR = 0x%x, rCNT = 0x%x\n",rIrDA_MDR, rIrDA_CNT);

	// Interrupt & DMA Control Register
	rIrDA_CNF = 0x0;		// Disable Interrupt & DMA

	// Interrupt Enable Register
	rIrDA_IER = 0x0;		// Disable All interrupts

	// FIFO Control Register
	// Tx FIFO reset[2] / RX FIFO reset[1]
	rIrDA_FCR = (RXTXTRIG<<6)|(IrDA_FIFOSIZE<<5)|(1<<2)|(1<<1)|(IrDA_FIFOENB);

	// Set Start Field Register or Preamble length
	rIrDA_PLR= ((PREAMBLE << 6) | (RXTXTRIG<<4) | STARTFLAG);

	// Receive Frame Length Register
	rIrDA_RXFLL = RXTXFL & 0xff;
	rIrDA_RXFLH= (RXTXFL>>8) & 0xff;
	printf(" [RXFL-L] %d, [RXFL-H] %d\n", (unsigned char)rIrDA_RXFLL, (unsigned char)rIrDA_RXFLH);

	// Transmit Frame Length Register
	rIrDA_TXFLL = RXTXFL & 0xff;
	rIrDA_TXFLH= (RXTXFL>>8) & 0xff;
	printf(" [TXFL-L] %d, [TXFL-H] %d\n", (unsigned char)rIrDA_TXFLL, (unsigned char)rIrDA_TXFLH);

	while(!(rIrDA_FCR & 0x18)) 
		if(Uart_GetKey()) return 2;

	printf("Tx and Rx FIFO clear is over...\n");
	return 1;
}


// IrDA Interrupt Test Code Start============================================================[END]
#if 1
void __irq Irda_Int_Rx(void)
{
	unsigned char status=0;
	unsigned char RxCount=0;

//	printf("E");
	// masking
	rINTMSK |= BIT_IrDA;

	// clear pending bit
	status = (unsigned char)rIrDA_IIR; // Sub-sub pending clear

	ClearPending(BIT_IrDA);

//	printf("rIrDA_IIR=%x\n",status);	
	
	if(status & (1<<6)) // RX error indication
	{ 
		__sub_Irda_Err_Int_Rx();
	}
	else 
	{
		if(status & 1) 
		{
//			printf("R");
			while(rIrDA_RXNO > 0) 
			{
				*(IrDA_RXBUFFER+IrDA_RxWrPnt) = (unsigned char)rIrDA_RBR;
				IrDA_RxWrPnt++;
				IrDA_RxCount++;
//				IrDA_DONE = 0;
			}
		} 
		if(status & (1<<3))  // RX Overrun
			printf("IrDA Rx Overrun Error Occurs!!\n");
		if((status & (1<<7)) || (status & (1<<4)))
		{
//			RxCount = rIrDA_RXNO;
//			while(rIrDA_RXNO > 0) 
//			{
//				*(IrDA_RXBUFFER+IrDA_RxWrPnt) = (unsigned char)rIrDA_RBR;
//				IrDA_RxWrPnt++;
//				IrDA_RxCount++;
//			}
//			printf("\nLast byte to Rx FIFO !!!!!!!!!\n");
//			IrDA_DONE = 0;
		}
		if(status & (1<<2)) 
		{ // last byte read from Rx FIFO
//			printf("\nLast byte read from Rx FIFO !!!!!!!!!\n");		
		}
	}
	// unmasking
	rINTMSK    &= ~BIT_IrDA;		
}

#else
void __irq Irda_Int_Rx(void)
{
	unsigned char status=0;
	unsigned char i,j,RxNO;
	
	RxISR_cnt++;
	// masking	
	rINTMSK    |= BIT_IrDA;

	// clear pending bit
	status = (unsigned char)rIrDA_IIR; // Sub-sub pending clear
	RxNO =(unsigned char)rIrDA_RXNO;

	ClearPending(BIT_IrDA);

	if(status & (1<<6))  // RX error indication
		{
		IrDA_DONE=0;
		ClearPending(BIT_IrDA);
		printf("Line Status Error\n");
		__sub_Irda_Err_Int_Rx();
		}

	else if(status & (1<<2))//Last byte detect
		{
		IrDA_DONE=0;
		//printf("\nLast byte detect\n");
		while( !(rIrDA_LSR&0x1))
			{
			printf("\1\n");
			*(IrDA_RXBUFFER+IrDA_RxWrPnt) = (unsigned char)rIrDA_RBR;
			*(IrDA_CKBUFFER+IrDA_RxWrPnt) = (unsigned char)rIrDA_RXNO;
			IrDA_RxWrPnt++;
			}		

		ClearPending(BIT_IrDA);	
		}
	
	else if(status & (1<<3)) //Overrun Error
		{
		IrDA_DONE=0;
		//rIrDA_IIR&=~(0x8);
		ClearPending(BIT_IrDA);
		printf("Overrun Error\n");
		}
	

	else
		{
		IrDA_DONE=0;
		
		while( !(rIrDA_LSR&0x1)||(status & (1<<2)))
			{		
			*(IrDA_RXBUFFER+IrDA_RxWrPnt) = (unsigned char)rIrDA_RBR;
			*(IrDA_CKBUFFER+IrDA_RxWrPnt) = (unsigned char)rIrDA_RXNO;
			IrDA_RxWrPnt++;
		    
			}
		}
		
	ClearPending(BIT_IrDA);

	// unmasking
	rINTMSK    &= ~BIT_IrDA;		
}

#endif
void __sub_Irda_Err_Int_Rx()
{
	switch((rIrDA_LSR & 0x1c)>>2)//to clear and check the status of register bits
	{
		case 1:
			printf("CRC error\n");
			break;
		case 2:
			printf("Phy error\n");
			break;
		case 3:
			printf("CRC and Phy error\n");
			break;
		case 4:
			printf("Frame Length error\n");
			break;
		case 5:
			printf("CRC and Frame Length error\n");
			break;
		case 6:
			printf("Phy and Frame Length error\n");
			break;
		case 7:
			printf("CRC, Phy and Frame Length error\n");
			break;
	}
}


void Test_Irda_Fifo_Int_Rx(int MODE, int PREAMBLE, int STARTFLAG, int RXFL, int RXTRIG)
{
	int	i;

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

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

	ClearPending(BIT_IrDA);	// Clear IrDA Int Pending

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

	IrDA_RXBUFFER=(unsigned char *)MemoryRx;
	for(i=0;i<=IrDA_RxBUFLEN;i++)
		*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++)