interrupt.c

2440超级bios（ads1.2 rvds2.2）通用

#ifndef __INTERRUPT_C__
#define __INTERRUPT_C__

#include "Includes.h"

#define CLR_EP3_OUT_PKT_READY() rOUT_CSR1_REG = \
								( out_csr3 &(~ EPO_WR_BITS)\
								&(~EPO_OUT_PKT_READY) ) 
#define SET_EP3_SEND_STALL()	rOUT_CSR1_REG = \
								( out_csr3 & (~EPO_WR_BITS)\
								| EPO_SEND_STALL) )
#define CLR_EP3_SENT_STALL()	rOUT_CSR1_REG= \
								( out_csr3 & (~EPO_WR_BITS)\
								&(~EPO_SENT_STALL) )
#define FLUSH_EP3_FIFO() 		rOUT_CSR1_REG = \
								( out_csr3 & (~EPO_WR_BITS)\
								|EPO_FIFO_FLUSH) )

void ClrPending(int bit)
{
	register i;
	
	rSRCPND = bit;
	rINTPND = bit;
	i = rINTPND;
}
void ClrSubPending(int bit)
{
	register i;
	
	rSUBSRCPND = bit;
	i = rINTPND;
}                       
void HaltUndef(void)
{
	while(1);
}
void HaltSwi(void)
{
    while(1);
}
void HaltPabort(void)
{
    while(1);
}
void HaltDabort(void)
{
    while(1);
}
void __irq Irq_eint0(void)
{
    rSRCPND = BIT_EINT0;
    rINTPND = BIT_EINT0;
    rINTPND;
	bitflags.bits.irq_eint0 = 1;
}
void __irq Irq_eint1(void)
{
    rSRCPND = BIT_EINT1;
    rINTPND = BIT_EINT1;
    rINTPND;
	bitflags.bits.irq_eint1 = 1;
}
void __irq Irq_eint2(void)
{
    rSRCPND = BIT_EINT2;
    rINTPND = BIT_EINT2;
    rINTPND;
	bitflags.bits.irq_eint2 = 1;
}
void __irq Irq_eint3(void)
{
    rSRCPND = BIT_EINT3;
    rINTPND = BIT_EINT3;
    rINTPND;
	bitflags.bits.irq_eint3 = 1;
}
void __irq Irq_eint4_7(void)
{
	bitflags.bits.irq_eint4_7 = 1;
}
void __irq Irq_eint8_23(void)
{
	bitflags.bits.irq_eint8_23 = 1;
}
void __irq Irq_cam(void)
{
	bitflags.bits.irq_cam = 1;
}
void __irq Irq_batt_flt(void)
{
	bitflags.bits.irq_batt_flt = 1;
}
void __irq Irq_tick(void)
{
    rSRCPND = BIT_RTC;
    rINTPND = BIT_RTC;
    rINTPND;
	UartPrintf(SHL_PRT,"tick\n");
	bitflags.bits.irq_tick = 1;
}
void __irq Irq_wdt_ac97(void)
{
	bitflags.bits.irq_wdt_ac97 = 1;
}
void __irq Irq_timer0(void)
{
    rSRCPND = BIT_TIMER0;       //Clear pending bit
    rINTPND = BIT_TIMER0;
    rINTPND;                    //Prevent an double interrupt pending
	bitflags.bits.irq_timer0 = 1;
}
void __irq Irq_timer1(void)
{
    rSRCPND = BIT_TIMER1;       //Clear pending bit
    rINTPND = BIT_TIMER1;
    rINTPND;
	bitflags.bits.irq_timer1 = 1;	
}
void __irq Irq_timer2(void)
{
    rSRCPND = BIT_TIMER2;       //Clear pending bit
    rINTPND = BIT_TIMER2;
    rINTPND;
	bitflags.bits.irq_timer2 = 1;
}
void __irq Irq_timer3(void)
{
    rSRCPND = BIT_TIMER3;       //Clear pending bit
    rINTPND = BIT_TIMER3;
    rINTPND;
	bitflags.bits.irq_timer3 = 1;
}
void __irq Irq_timer4(void)
{
    rSRCPND = BIT_TIMER4;       //Clear pending bit
    rINTPND = BIT_TIMER4;
    rINTPND;
	bitflags.bits.irq_timer4 = 1;
}
void __irq Irq_uart2(void)
{
    ClrSubPending(BIT_SUB_RXD2);
    ClrPending(BIT_UART2);
	if (rUTRSTAT2 & 0x1)
	{
		// Receive data ready
		qUart0_R_buf[qUart0_R_len] = RdURXH2();
		if(qUart0_R_len < UART0_R_MAX)
			qUart0_R_len++;
		else
			qUart0_R_len = 0;
		bitflags.bits.irq_uart2 = 1;
	}
}
void __irq Irq_lcd(void)
{
	bitflags.bits.irq_lcd = 1;
}
void __irq Irq_dma0(void)
{
	bitflags.bits.irq_dma0 = 1;
}
void __irq Irq_dma1(void)
{
	bitflags.bits.irq_dma1 = 1;
}
void __irq Irq_dma2(void)
{
    U08 out_csr3;
    U32 nextTotalDmaCount;
    U08 saveIndexReg = rINDEX_REG;

    rINDEX_REG = 3;
    out_csr3 = rOUT_CSR1_REG;
    ClearPending(BIT_DMA2);
    totalDmaCount += 0x80000;
    if(totalDmaCount >= downloadFileSize)// is last?
    {
		totalDmaCount = downloadFileSize;
    	ConfigEp3IntMode();
    	if(out_csr3& EPO_OUT_PKT_READY)
	   	    CLR_EP3_OUT_PKT_READY();
        rINTMSK |= BIT_DMA2;
        rINTMSK &= ~(BIT_USBD);
    }
    else
    {
    	if((totalDmaCount+0x80000) < downloadFileSize)
    	{
		    nextTotalDmaCount = totalDmaCount+0x80000;
    	    if((nextTotalDmaCount+0x80000) < downloadFileSize)	//for (2~n)th autoreload
    	    {
				rDIDST2 = ((U32)downloadAddress+nextTotalDmaCount-8);
				rDIDSTC2 = (1<<2)|(0<<1)|(0<<0);
	        	rDCON2 = rDCON2&~(0xfffff)|(0x80000);
    	    	while(rEP3_DMA_TTC < 0xfffff)
    	    	{
    	    	    rEP3_DMA_TTC_L = 0xff;
    	    	    rEP3_DMA_TTC_M = 0xff;
    	    	    rEP3_DMA_TTC_H = 0xf;
    	    	}
	   	    }
 		    else
 		    {
   	    	    rDIDST2= ((U32)downloadAddress+nextTotalDmaCount-8);
	      	    rDIDSTC2 = (0<<1) | (0<<0);
    	  	    rDCON2= rDCON2&~(0xfffff)|(downloadFileSize-nextTotalDmaCount);
   	    		while(rEP3_DMA_TTC < 0xfffff)
   	    		{
   	    		    rEP3_DMA_TTC_L = 0xff;
   	    	    	rEP3_DMA_TTC_M = 0xff;
	   	    	    rEP3_DMA_TTC_H = 0xf;
   		    	}
	    	}
		}
		else
  	    	rDIDSTC2 = (0<<1)|(0<<0);  // reload is occurred when Curr_TC is 0
    }
    rINDEX_REG = saveIndexReg;
	bitflags.bits.irq_dma2 = 1;
}
void __irq Irq_dma3(void)
{
	bitflags.bits.irq_dma3 = 1;
}
void __irq Irq_sdi(void)
{
	bitflags.bits.irq_sdi = 1;
}
void __irq Irq_spi0(void)
{
	bitflags.bits.irq_spi0 = 1;
}
void __irq Irq_uart1(void)
{
    ClrSubPending(BIT_SUB_RXD1);
    ClrPending(BIT_UART1);
	// Receive data ready
	qUart1_R_buf[qUart1_R_len] = RdURXH1();
	if(qUart1_R_len < UART1_R_MAX)
		qUart1_R_len++;
	else
		qUart0_R_len = 0;
	bitflags.bits.irq_uart1 = 1;
}
void __irq Irq_nfcon(void)
{
	bitflags.bits.irq_nfcon = 1;
}
void __irq Irq_usbd(void)
{
    U08 usbdIntpnd,epIntpnd;
    U08 saveIndexReg = rINDEX_REG;
    
    usbdIntpnd = rUSB_INT_REG;
    epIntpnd = rEP_INT_REG;
    if(usbdIntpnd & SUSPEND_INT)
    	rUSB_INT_REG = SUSPEND_INT;
    if(usbdIntpnd & RESUME_INT)
    	rUSB_INT_REG = RESUME_INT;
    if(usbdIntpnd & RESET_INT)
    {
    	ReconfigUsbd();
    	rUSB_INT_REG = RESET_INT;  // RESET_INT should be cleared after ResetUsbd().   	
        PrepareEp1Fifo();
    }
    if(epIntpnd&EP0_INT)
    {
		rEP_INT_REG = EP0_INT;
    	Ep0Handler();
    }
    if(epIntpnd&EP1_INT)
    {
    	rEP_INT_REG = EP1_INT;
    	Ep1Handler();
    }
    if(epIntpnd&EP2_INT)
    {
    	rEP_INT_REG = EP2_INT;  
    	//Ep2Handler();
    }
    if(epIntpnd&EP3_INT)
    {
    	rEP_INT_REG = EP3_INT;
    	Ep3Handler();
    }
    if(epIntpnd&EP4_INT)
    {
    	rEP_INT_REG = EP4_INT;
    	//Ep4Handler();
    }
    ClearPending(BIT_USBD);
    
    rINDEX_REG = saveIndexReg;
	bitflags.bits.irq_usbd = 1;
}
void __irq Irq_usbh(void)
{
	bitflags.bits.irq_usbh = 1;
}
void __irq Irq_iic(void)
{
	bitflags.bits.irq_iic = 1;
}
void __irq Irq_uart0(void)
{
    ClrSubPending(BIT_SUB_RXD0);
    ClrPending(BIT_UART0);
	// Receive data ready
	qUart0_R_buf[qUart0_R_len] = RdURXH0();
	if(qUart0_R_len < UART0_R_MAX)
		qUart0_R_len++;
	else
		qUart0_R_len = 0;
	bitflags.bits.irq_uart0 = 1;
}
void __irq Irq_spi1(void)
{
	bitflags.bits.irq_spi1 = 1;
}
void __irq Irq_rtc(void)
{
    rSRCPND = BIT_RTC;
    rINTPND = BIT_RTC;
    rINTPND;
	UartPrintf(SHL_PRT,"rtc\n");
	bitflags.bits.irq_rtcint = 1;
}
void __irq Irq_adc(void)
{
	int i;

    if(rADCDAT0 & 0x8000)
    {
		UartPrintf(1,"\nStylus Up!\n");
		rADCTSC &= 0x00ff;					//Set stylus down interrupt bit
    }
    else
		UartPrintf(1,"\nStylus Down!\n");
	rADCTSC = (1<<3)|(1<<2);				//Pull-up disable, Seq. X,Y postion measure.
	rADCDLY = 40000;						//Normal conversion mode delay about (1/50M)*40000=0.8ms
	rADCCON |= 0x1;							//start ADC

	while(rADCCON & 0x1);					//check if Enable_start is low
	while(!(rADCCON & 0x8000));				//check if EC(End of Conversion) flag is high, This line is necessary~!!
	while(!(rSRCPND & (BIT_ADC)));			//check if ADC is finished with interrupt bit
    xdata = (rADCDAT0 & 0x3ff);
    ydata = (rADCDAT1 & 0x3ff);
	
	rSUBSRCPND |= BIT_SUB_TC;				//YH 0627, To check Stylus Up Interrupt.
	ClrPending(BIT_ADC);
			 
	rADCTSC = 0xd3;							//Waiting for interrupt
	rADCTSC = rADCTSC|(1<<8);				//Detect stylus up interrupt signal.
	while(1)								//to check Pen-up state
	{
		if(rSUBSRCPND & (BIT_SUB_TC))		//check if ADC is finished with interrupt bit
		{
			UartPrintf(1,"Stylus Up Int!\n");
			break;							//if Stylus is up(1) state
		}
	}	
    UartPrintf(1,"XP=%04d,YP=%04d\n",xdata,ydata); //X-position Conversion data            
	rADCTSC = rADCTSC&~(1<<8);				//Detect stylus Down interrupt signal.
    rSUBSRCPND |= BIT_SUB_TC;
    ClrPending(BIT_ADC);
	//bitflags.bits.irq_adc_ts = 1;
}
void Isr_init(void)
{
    rINTMOD		= 0x0;					//All=IRQ mode
    rINTMSK		= BIT_ALLMSK;			//All interrupt is masked.
    rINTSUBMSK  = BIT_SUB_ALLMSK;		//All sub-interrupt is masked. <- April 01, 2002 SOP

    pISR_UNDEF		= (U32)HaltUndef;
    pISR_SWI		= (U32)HaltSwi;
    pISR_PABORT		= (U32)HaltPabort;
    pISR_DABORT		= (U32)HaltDabort;

	pISR_EINT0		= (U32)Irq_eint0;
	pISR_EINT1		= (U32)Irq_eint1;
	pISR_EINT2		= (U32)Irq_eint2;
	pISR_EINT3		= (U32)Irq_eint3;
	pISR_EINT4_7	= (U32)Irq_eint4_7;
	pISR_EINT8_23	= (U32)Irq_eint8_23;
	pISR_CAM		= (U32)Irq_cam;
	pISR_BAT_FLT	= (U32)Irq_batt_flt;
	pISR_TICK		= (U32)Irq_tick;
	pISR_WDT_AC97	= (U32)Irq_wdt_ac97;
	pISR_TIMER0		= (U32)Irq_timer0;
	pISR_TIMER1		= (U32)Irq_timer1;
	pISR_TIMER2		= (U32)Irq_timer2;
	pISR_TIMER3		= (U32)Irq_timer3;
	pISR_TIMER4		= (U32)Irq_timer4;
	pISR_UART2		= (U32)Irq_uart2;
	pISR_LCD		= (U32)Irq_lcd;
	pISR_DMA0		= (U32)Irq_dma0;
	pISR_DMA1		= (U32)Irq_dma1;
	pISR_DMA2		= (U32)Irq_dma2;
	pISR_DMA3		= (U32)Irq_dma3;
	pISR_SDI		= (U32)Irq_sdi;
	pISR_SPI0		= (U32)Irq_spi0;
	pISR_UART1		= (U32)Irq_uart1;
	pISR_NFCON		= (U32)Irq_nfcon;
	pISR_USBD		= (U32)Irq_usbd;
	pISR_USBH		= (U32)Irq_usbh;
	pISR_IIC		= (U32)Irq_iic;
	pISR_UART0		= (U32)Irq_uart0;
	pISR_SPI1		= (U32)Irq_spi1;
	pISR_RTC		= (U32)Irq_rtc;
    pISR_ADC		= (U32)Irq_adc;
	ClrSubPending(BIT_SUB_RXD0);
	ClrPending(BIT_UART0);
	ClrSubPending(BIT_SUB_RXD1);
	ClrPending(BIT_UART1);
	ClrSubPending(BIT_SUB_RXD2);
	ClrPending(BIT_UART2);
	ClrPending(BIT_DMA2);
	ClrPending(BIT_USBD);

	rINTSUBMSK	= ~(BIT_SUB_RXD2 |
//					BIT_SUB_RXD1 |
					BIT_SUB_RXD0 |
					BIT_SUB_TC);
	rINTMSK		&= EN_TIMER0;
	rINTMSK		&= EN_TIMER1;
	rINTMSK		&= EN_TIMER2;
	rINTMSK		&= EN_TIMER3;
	rINTMSK		&= EN_TIMER4;
	rINTMSK		&= EN_UART0;
//	rINTMSK		&= EN_UART1;
	rINTMSK		&= EN_UART2;
	rINTMSK		&= EN_ADC;
	rINTMSK		&= EN_USBD;
	rINTMSK		&= EN_DMA2;
	rINTMSK		&= EN_TICK;
	rINTMSK		&= EN_RTC;
}

#endif