/*********************************************************************************************
* File：	irda_test.c
* Author:	embest
* Desc：	IrDA test
* History:	
*			W.W.Zhang, Programming modify, May,8, 2005
*********************************************************************************************/

#include <string.h>
#include "2410lib.h"
#include "irda_test.h"

/*********************************************************************************************
* name:		irda_port_set
* func:		save and set the IrDA port
* para:		none
* ret:		none
* modify:
* comment:		
*********************************************************************************************/
void irda_port_set(void)
{
    //Push UART GPIO port configuration
    sirda_rGPBCON=rGPBCON; 
    sirda_rGPBDAT=rGPBDAT;
    sirda_rGPBUP=rGPBUP;
    sirda_rGPHCON=rGPHCON; 
    sirda_rGPHDAT=rGPHDAT;
    sirda_rGPHUP=rGPHUP;
    
    //Configure IrDA port
    rGPBCON &= 0x3ffff3;
    rGPBCON |= (1<<2);								// Output(nIrDATXDEN)
    rGPBUP  |= (1<<1);								// Uart port pull-up disable
    rGPBDAT |= (1<<1);	
    rGPHCON &= 0x3FF0FF;
    rGPHCON |= 0x0a00;								// TXD1,RXD1
    rGPHUP  |= 0x7ff;								// Uart port pull-up disable
    
    //Push Uart control registers 
    sirda_ULCON1=rULCON1;		
    sirda_UCON1 =rUCON1;		
    sirda_UFCON1=rUFCON1;		
    sirda_UMCON1=rUMCON1;
    sirda_UBRDIV1=rUBRDIV1;
}       
        
/*********************************************************************************************
* name:		irda_port_return
* func:		restore the port setting value
* para:		none
* ret:		none
* modify:
* comment:		
*********************************************************************************************/
void irda_port_return(void)
{       
    //Pop UART GPIO port configuration
    rGPBCON=sirda_rGPBCON;
    rGPBDAT=sirda_rGPBDAT;
    rGPBUP =sirda_rGPBUP;
    rGPHCON=sirda_rGPHCON;
    rGPHDAT=sirda_rGPHDAT;
    rGPHUP =sirda_rGPHUP;
    
    //Pop Uart control registers 
    rULCON1=sirda_ULCON1;		
    rUCON1 =sirda_UCON1;	
    rUFCON1=sirda_UFCON1;		
    rUMCON1=sirda_UMCON1;
    rUBRDIV1=sirda_UBRDIV1;
}

/*********************************************************************************************
* name:		irda_tx_int
* func:		IrDA transmit interrupt handler
* para:		none
* ret:		none
* modify:
* comment:		
*********************************************************************************************/
void irda_tx_int(void)
{
	rINTSUBMSK |= (BIT_SUB_RXD1|BIT_SUB_TXD1|BIT_SUB_ERR1);
	if(IrDA_cnt < (IrDA_BUFLEN))
	{
		uart_printf(" %d,",*IrDAdataPt);
		WrUTXH1(*IrDAdataPt++);
		IrDA_cnt++;
		
	    rSUBSRCPND = (BIT_SUB_TXD1);
        rINTSUBMSK &= ~(BIT_SUB_TXD1);
		ClearPending(BIT_UART1);
    }
    else
    {
		IrDA_end=1;
		while(rUFSTAT1 & 0x2f0);					//Until FIFO is empty
		while(!(rUTRSTAT1 & 0x4))					//Until Tx shifter is empty
    	ClearPending(BIT_UART1);
		rINTMSK |= BIT_UART1;
    }
}

/*********************************************************************************************
* name:		irda_rx_or_err
* func:		IrDA receive or error interrupt entry point
* para:		none
* ret:		none
* modify:
* comment:		
*********************************************************************************************/
void irda_rx_or_err(void)
{
    rINTSUBMSK |= (BIT_SUB_RXD1|BIT_SUB_TXD1|BIT_SUB_ERR1);	// Just for the safety
    if(rSUBSRCPND & BIT_SUB_RXD1)
    	irda_rx_int();
    else
    	irda_rx_int_err();
    rSUBSRCPND = (BIT_SUB_RXD1 | BIT_SUB_TXD1 | BIT_SUB_ERR1);
    rINTSUBMSK &= ~(BIT_SUB_RXD1|BIT_SUB_ERR1);
    ClearPending(BIT_UART1);
}

/*********************************************************************************************
* name:		irda_rx_int
* func:		IrDA receive interrupt handle function
* para:		none
* ret:		none
* modify:
* comment:		
*********************************************************************************************/
void irda_rx_int(void)
{
    while( (rUFSTAT1 & 0x100) || (rUFSTAT1 & 0xf)  )
    {
		*IrDAdataPt = rURXH1;
		uart_printf(" %d,",*IrDAdataPt++);
		IrDA_cnt++;
    }
    if(IrDA_cnt >= IrDA_BUFLEN)
    {
    	IrDA_end = 1;
    	rINTMSK |= BIT_UART1;
    }
}

/*********************************************************************************************
* name:		irda_rx_int_err
* func:		IrDA transmit interrupt handle function
* para:		none
* ret:		none
* modify:
* comment:		
*********************************************************************************************/
void irda_rx_int_err(void)
{
    switch(rUERSTAT1)//to clear and check the status of register bits
    {
	case '1':
	    uart_printf(" Overrun error\n");
	    break;
	case '2':
	    uart_printf(" Parity error\n");
	    break;
	case '4':
	    uart_printf(" Frame error\n");
	    break;
	case '8':
	    uart_printf(" Breake detect\n");
	    break;
	default :
	    break;
    }
}

/*********************************************************************************************
* name:		irda_test_tx
* func:		IrDA transmit test function
* para:		none
* ret:		none
* modify:
* comment:		
*********************************************************************************************/
void irda_test_tx(void)
{
    int i;
    IrDA_cnt=0;
    IrDA_end=0;
    IrDAdataFl=(volatile UINT8T *)IrDABUFFER;
    IrDAdataPt=(volatile UINT8T *)IrDABUFFER;
    irda_port_set();
    uart_select(0);
/*    for(i=0;i<IrDA_BUFLEN;i++)
    	*IrDAdataFl++=i;						// Initialize IrDA Tx data
*/
    pISR_UART1=(UINT32T)irda_tx_int;
	uart_printf("\n IrDA Transfer Test Example\n");
    uart_printf(" Select the baud rate:\n");	// Select IrDA baud rate
    uart_printf(" 1)9600    2)19200    3)38400    4)57600    5)115200\n"); 
#ifdef BOARDTEST    
	i = '5';
#else
	i=uart_getch ();
#endif
    switch(i)
    {
	case '1':
		IrDA_BAUD=9600;
        break;
	
	case '2':
        IrDA_BAUD=19200;
        break;
	
	case '3':
        IrDA_BAUD=38400;
        break;
	
	case '4':
        IrDA_BAUD=57600;
        break;
	
	case '5':
        IrDA_BAUD=115200;
        break;
	
	default:
        break;
    }
    rUBRDIV1=( (int)(PCLK/16./IrDA_BAUD) -1 );
    uart_printf(" rUBRDIV1=%d\n", rUBRDIV1);
    uart_txempty(0);
    
    rGPBDAT &= ~(1<<1);                     // Enable nIrDATXDEN    
	//Tx and Rx FIFO Trigger Level:4byte,Tx and Rx FIFO Reset,FIFO on
	rUFCON1 = (1<<6) | (0<<4) | (1<<2) | (1<<1) | (1);
	// PCLK,Tx&Rx:Level,Rx timeout:x,Rx error int:x,Loop-back:x,Send break:x,Tx:x,Rx:x    
	rUCON1 = (0<<10) | (1<<9) | (1<<8) | (0<<7) | (0<<6) | (0<<5) | (0<<4) | (0<<2) | (0);
    // IrDA,No parity,One stop bit, 8bit
    rULCON1 = (1<<6) | (0<<3) | (0<<2) | (3);

    //uart_printf(" Press any key to start Tx first...\n");
    //uart_getch();
    rUCON1 = (0<<10) | (1<<9) | (1<<8) | (0<<7) | (0<<6) | (0<<5) | (0<<4) | (1<<2) | (0);
    // PCLK,Tx&Rx:Level,Rx timeout:x,Rx error int:x,Loop-back:x,Send break:x,Tx:int,Rx:x
    uart_printf(" Now... Tx with IrDA\n");

    rINTMSK    &=~ (BIT_UART1);
    rINTSUBMSK &=~ (BIT_SUB_RXD1|BIT_SUB_TXD1|BIT_SUB_ERR1);

    while(!IrDA_end);

    rINTSUBMSK |= (BIT_SUB_RXD1|BIT_SUB_TXD1|BIT_SUB_ERR1);
    rUFCON1 = (3<<6)|(2<<4)|(1<<2)|(1<<1)|(0);
    rGPBDAT |= (1<<1);							// Disable nIrDATXDEN        
    uart_printf("\n Transfer data count: %d\n",IrDA_cnt);
    
    rINTMSK    |= BIT_UART1;
    rINTSUBMSK |= (BIT_SUB_RXD1|BIT_SUB_TXD1|BIT_SUB_ERR1);
    irda_port_return();
}

/*********************************************************************************************
* name:		irda_test_rx
* func:		IrDA receive test function
* para:		none
* ret:		none
* modify:
* comment:		
*********************************************************************************************/
void irda_test_rx(void)
{
    unsigned int i;
    IrDA_cnt=0;
    IrDA_end=0;
    IrDA_err=0;
    IrDAdataFl = (volatile UINT8T *)IrDABUFFER;
    IrDAdataPt = (volatile UINT8T *)IrDABUFFER;
    irda_port_set();    
    uart_select(0);
    pISR_UART1 = (unsigned)irda_rx_or_err;
	uart_printf("\n IrDA Receive Test Example\n");
    uart_printf(" Select the baud rate:\n");	// Select IrDA baud rate
    uart_printf(" 1)9600    2)19200    3)38400    4)57600    5)115200\n"); 
#ifdef BOARDTEST    
	i = '5';
#else
	i=uart_getch ();
#endif
    switch(i)
    {
	case '1':
            IrDA_BAUD=9600;
	        break;
	
	case '2':
            IrDA_BAUD=19200;
	        break;
	
	case '3':
            IrDA_BAUD=38400;
	        break;
	
	case '4':
            IrDA_BAUD=57600;
	        break;
	
	case '5':
            IrDA_BAUD=115200;
	        break;
		
	default:
			break;
    }
    
    rUBRDIV1=( (int)(PCLK/16./IrDA_BAUD) -1 );
    uart_printf(" rUBRDIV1=%d\n", rUBRDIV1);
    
    rGPBDAT &= ~(1<<1);                     // Enable nIrDATXDEN
    //Tx and Rx FIFO Trigger Level:4byte,Tx and Rx Reset,FIFO En
    rUFCON1 = (1<<6) | (0<<4) | (1<<2) | (1<<1) | (1);
    // PCLK,Tx&Rx:Level,Rx timeout:x,Rx error int:o,Loop-back:x,Send break:x,Tx:x,Rx:x
    rUCON1 = (0<<10) | (1<<9) | (1<<8) | (0<<7) | (1<<6) | (0<<5) | (0<<4) | (0<<2) | (0);
    // Infra-red mode,No parity,One stop bit, 8bit
    rULCON1 = (1<<6) | (0<<3) | (0<<2) | (3);	
    delay(1);
    // PCLK,Tx&Rx:Level,Rx timeout:x,Rx error int:o,Loop-back:x,Send break:x,Tx:x,Rx:int
    rUCON1 = (0<<10) | (1<<9)| (1<<8) | (0<<7) | (1<<6) | (0<<5) | (0<<4) | (0<<2) | (1);
    
    //uart_printf(" Press any key to start Rx ...\n");
    //uart_getch();
    uart_printf(" Now... Rx with IrDA\n");

    rINTMSK    &= ~(BIT_UART1);
    rINTSUBMSK &= ~(BIT_SUB_RXD1|BIT_SUB_ERR1);
    
    while(!IrDA_end);
    
    rINTMSK    |= BIT_UART1;
    rINTSUBMSK |= (BIT_SUB_RXD1 | BIT_SUB_TXD1 | BIT_SUB_ERR1);

    rUFCON1 = (3<<6) | (2<<4) | (1<<2) | (1<<1) | (0);
    irda_port_return();
}

/*********************************************************************************************
* name:		irda_test
* func:		IrDA receive and transfer test function
* para:		none
* ret:		none
* modify:
* comment:		
*********************************************************************************************/
void irda_test(void)
{
	UINT32T szBuf[40];
	
#ifdef BOARDTEST
	Lcd_DspAscII6x8(195,170,0x1c,"Wait to Receive...");	
#endif	
	irda_test_rx();
	
#ifdef BOARDTEST
	Lcd_DspAscII6x8(195,180,0x1c,"And Send them...");	
	print_lcd(195,190,0x1c,"The first word: ");
	sprintf(&szBuf, "0x%x",*(int *)IrDABUFFER);
	print_lcd(200,200,0x1c,&szBuf);
#endif

	irda_test_tx();
	
	uart_printf(" end.\n");
}