interrupt.c

Ep93XX TionProV2 BSP

        case SYSINTR_UART1:
            *pulInterruptMask1  = 0;
            *pulInterruptMask2  = INT2_UART1;
            break;

        case SYSINTR_UART2:
            *pulInterruptMask1  = 0;
            *pulInterruptMask2  = INT2_UART2;
            break;

        case SYSINTR_UART3:
            *pulInterruptMask1  = 0;
            *pulInterruptMask2  = INT2_UART3;
            break;            

        case SYSINTR_KEYBOARD:
            *pulInterruptMask1  = INT1_KEYPAD;
            *pulInterruptMask2  = 0;
            break;

        case SYSINTR_SPI:
            *pulInterruptMask1  = 0;
            *pulInterruptMask2  = INT2_SPI;
            break;

        case SYSINTR_RTC_ALARM:
            *pulInterruptMask1  = 0;
            *pulInterruptMask2  = INT2_RTC;
            break;

        case SYSINTR_DMA0:
        case SYSINTR_DMA1:
        //case SYSINTR_DMA2:
        //case SYSINTR_DMA3:
        //case SYSINTR_DMA4:
        //case SYSINTR_DMA5:
        //case SYSINTR_DMA6:
        //case SYSINTR_DMA7:
        //case SYSINTR_DMA8:
        //case SYSINTR_DMA9:
            *pulInterruptMask1  = INT1_DMAM2P0<< (dwSysIntr - SYSINTR_DMA0);
            *pulInterruptMask2  = 0;
            break;

        case SYSINTR_TOUCH:
            *pulInterruptMask1  = INT1_TOUCH;
            *pulInterruptMask2  = 0;
            break;

        case SYSINTR_TIMER2:
            *pulInterruptMask1  = INT1_TIMER2;
            *pulInterruptMask2  = 0;
            break;

#ifdef EDB9315A_CIR
		case SYSINTR_PIO_CIR:
            *pulInterruptMask1  = 0;
            *pulInterruptMask2  = INT2_GPIO;
            break;
#else
        case SYSINTR_IR:
            *pulInterruptMask1  = 0;
            *pulInterruptMask2  = INT2_IRDA;
            break;
#endif
        case SYSINTR_IDE:
            *pulInterruptMask1  = 0;
            *pulInterruptMask2  = INT2_EXT3;
            break;

#ifdef EP93XX_SIMULAT_PS2_KBD

        case SYSINTR_PS2_PORT:

			//RETAILMSG(1, (TEXT("SYSINTR_PS2_PORT\r\n")));
            *pulInterruptMask1  = 0;
            *pulInterruptMask2  = 0; // the PS2 KeyBoard driver only  see a pseudo interrupt. so don't care the interrupt.
            break;

#endif


#ifdef   EP93XX_SD_MMC

	 case SYSINTR_CARD_RESPONSE:
		 //RETAILMSG(1,(L"SD_MMC response done\n"));
           *pulInterruptMask1  = 0;
            *pulInterruptMask2  = INT2_EXT1;
            break;

	 case SYSINTR_CARD_DETECT:
            *pulInterruptMask1  = 0;
            *pulInterruptMask2  = INT2_EXT1;
            break;	

#elif  EP93XX_MS_CARD

	 case SYSINTR_CARD_RESPONSE:

		    *pulInterruptMask1  = 0;
            *pulInterruptMask2  = INT2_EXT2;
            break;

	 case SYSINTR_CARD_DETECT:
            *pulInterruptMask1  = 0;
            *pulInterruptMask2  = INT2_EXT2;
            break;
#endif

#ifdef EP93XX_USB_SLAVE

        case SYSINTR_USBSLAVE:

			//RETAILMSG(1, (TEXT("SYSINTR_PS2_PORT\r\n")));
            *pulInterruptMask1  = 0;
            *pulInterruptMask2  = INT2_EXT0; // the PS2 KeyBoard driver only  see a pseudo interrupt. so don't care the interrupt.
            break;

#endif

        case SYSINTR_PCMCIA_LEVEL:
            *pulInterruptMask1  = 0;
            *pulInterruptMask2  = INT2_PCMCIA_IRQ;
            break;
        case SYSINTR_PCMCIA_STATE:
            *pulInterruptMask1  = INT1_PCMCIA_CD1 | INT1_PCMCIA_CD2 | INT1_PCMCIA_BVD1;
            *pulInterruptMask2  = INT2_PCMCIA_BVD2;
            break;
    
        case SYSINTR_DMA_M2M0:
            *pulInterruptMask1  = INT1_DMAM2M0;
            *pulInterruptMask2  = 0;
            break;
        case SYSINTR_DMA_M2M1:
            *pulInterruptMask1  = INT1_DMAM2M1;
            *pulInterruptMask2  = 0;
            break;

        case SYSINTR_PIO_PLAYBACK:
            *pulInterruptMask1  = INT1_UNUSED1;
            *pulInterruptMask2  = 0;
            break;

        case SYSINTR_PIO_RECORD:
            *pulInterruptMask1  = INT1_UNUSED2;
            *pulInterruptMask2  = 0;
            break;
        default:
            *pulInterruptMask1  = 0;
            *pulInterruptMask2  = 0;
            bRet = FALSE;
            break;
    }
    return bRet;
}


/*
 * @func   BOOL | OEMInterruptEnable | Enable a hardware interrupt
 *
 * @parms
 *         idInt   Interrupt ID to be enabled.
 *                 See Interrupt ID's.Interrupt ID's>  for a list of
 *                 possble values.
 *
 *         pvData  ptr to data passed in in the InterruptInitialize() call
 *
 *         cbData  Size of data pointed to by pvData
 *
 * @rdesc  Returns TRUE if valid interrupt ID or FALSE if invalid ID.
 *
 * @comm   This function is called by the Kernel when a device driver
 *         calls InterruptInitialize(). The system is not preemptible
 *         when this function is called.
 *
 * @xref
 *         Overview.Windows CE Kernel OEM Interface
 *         InterruptInitialize
 */
BOOL OEMInterruptEnable(DWORD idInt, LPVOID pvData, DWORD cbData)
{
    BOOL    bRet = TRUE;
    ULONG   ulIntMask1, ulIntMask2;


    bRet = SysIntrNumToInterruptMask(idInt, &ulIntMask1, &ulIntMask2);
  
    INTERRUPTS_OFF();


    if(ulIntMask1)
    {
        *VIC1_INTENABLE     = ulIntMask1;
        gdwInterruptMask1   |= ulIntMask1;
    }

    if(ulIntMask2)
    {
        *VIC2_INTENABLE     = ulIntMask2;
        gdwInterruptMask2   |= ulIntMask2;
    }

    if(idInt ==SYSINTR_SPI)
    {
        fPS2Int             = 0;
    }

    if((idInt == SYSINTR_PIO_PLAYBACK) && (cbData == sizeof(PIOBufferParameters)) )
    {
        PIOBufferParameters *pPIO = (PIOBufferParameters *)pvData;

        sPlayBack.pulPosition   = sPlayBack.pulBuffer = pPIO->pulBuffer = gulTransmitBuffer;
        sPlayBack.ulBufferSize  = pPIO->ulBufferSize;
        sPlayBack.pulBufferEnd  = sPlayBack.pulBuffer + (sPlayBack.ulBufferSize>>2);
        sPlayBack.pulBufferHalf = sPlayBack.pulBuffer + (sPlayBack.ulBufferSize>>3);
        sPlayBack.bEnabled      = FALSE;
        sPlayBack.bIntEnabled   = TRUE;
        gbAC97                  = pPIO->bAC97;

        if(!sRecord.bIntEnabled )
        {
            if(pPIO->bAC97)
            {
                gdwInterruptMask1       |= INT1_AAC;
                *VIC1_INTSELECT         |= INT1_AAC;
                *VIC1_INTENABLE         = INT1_AAC;
            }
            else
            {
                gdwInterruptMask2       |= INT2_SAI;
                *VIC2_INTSELECT         |= INT2_SAI;
                *VIC2_INTENABLE         = INT2_SAI;
            }
        }
    }

    if((idInt == SYSINTR_PIO_RECORD) && (cbData == sizeof(PIOBufferParameters)) )
    {
        PIOBufferParameters *pPIO = (PIOBufferParameters *)pvData;

        sRecord.pulPosition     = sRecord.pulBuffer = pPIO->pulBuffer = gulRecieveBuffer;
        sRecord.ulBufferSize    = pPIO->ulBufferSize;
        sRecord.pulBufferEnd    = sRecord.pulBuffer + (sRecord.ulBufferSize>>2);
        sRecord.pulBufferHalf   = sRecord.pulBuffer + (sRecord.ulBufferSize>>3);
        sRecord.bEnabled        = FALSE;
        sRecord.bIntEnabled     = TRUE;
        gbAC97                  = pPIO->bAC97;

        if(!sPlayBack.bIntEnabled)
        {
            if(pPIO->bAC97)
            {
                gdwInterruptMask1   |= INT1_AAC;
                *VIC1_INTSELECT     |= INT1_AAC;
                *VIC1_INTENABLE     = INT1_AAC;
            }
            else
            {
                gdwInterruptMask2   |= INT2_SAI;
                *VIC2_INTSELECT     |= INT2_SAI;
                *VIC2_INTENABLE     = INT2_SAI;
            }
        }
    }
#ifdef EP93XX_SIMULAT_PS2_KBD
	if( idInt == SYSINTR_PS2_PORT ) //Initialize KeyBoard when driver calls InterruptInitialize( )
	{
		int init_edb931xPS2(void);

        *VIC2_INTENABLE     = INT2_EXT0;
        gdwInterruptMask2   |= INT2_EXT0;
		
		init_edb931xPS2( );
	}
#endif

#ifdef EDB9315A_CIR
	if( idInt == SYSINTR_PIO_CIR ) 
	{
		// Enable EGPIO13 for CIR interrupt.
		UINT value;

	    //OEMWriteDebugByte('E');
	    //OEMWriteDebugByte('\r');
	    //OEMWriteDebugByte('\n');
	    
		gnWi = 0;
		gnKeyCode = 0;

		value = *GPIO_PBDDR;
		value &= ~0x20;
		*GPIO_PBDDR = value; // Set port B as input

		value = *GPIO_BINTEN;
		value &= ~0x20;
		*GPIO_BINTEN = value; // Disable all interrupt.

		*GPIO_BEOI = 0x20; // Clean all previous interrupt

		value = *GPIO_BINTTYPE1;
		value |= 0x20; // edge trigure.
		*GPIO_BINTTYPE1 = value;

		value = *GPIO_BINTTYPE2;
		value &= ~0x20; // Falling edge 
		*GPIO_BINTTYPE2 = value;

		value = *GPIO_BINTEN;
		value |= 0x20; // Enable interrupt
		*GPIO_BINTEN = value;	
	}
#endif

    INTERRUPTS_ON();

    return(bRet);
}

/*
 * @func   BOOL | OEMInterruptDisable | Disable a hardware interrupt
 *
 * @rdesc  none
 *
 * @parms
 *         idInt   Interrupt ID to be disabled.
 *                 See Interrupt ID's.Interrupt ID's>  for a list of
 *                 possble values.
 *
 * @comm   OEMInterruptDisable is called by the Kernel when a device driver
 *         calls <f InterruptDisable>. The system is not preemtible when this
 *         function is called.
 *
 * @xref
 *         Overview.Windows CE Kernel OEM Interface
 *         InterruptDisable
 */
void OEMInterruptDisable(DWORD idInt)
{
    // NKDbgPrintfW(L"OEMInterruptDisable: Interrupt #%02d\r\n", idInt);

    BOOL    bRet = TRUE;
    ULONG   ulIntMask1, ulIntMask2;


    bRet = SysIntrNumToInterruptMask(idInt, &ulIntMask1, &ulIntMask2);
    INTERRUPTS_OFF();

    if(ulIntMask1)
    {
        *VIC1_INTCLEAR      = ulIntMask1;
        gdwInterruptMask1   &= ~ulIntMask1;
    }

    if(ulIntMask2)
    {
        *VIC2_INTCLEAR     = ulIntMask2;
        gdwInterruptMask2  &= ~ulIntMask2;
    }

    if(idInt == SYSINTR_PIO_PLAYBACK )
    {
        if(!sRecord.bIntEnabled)
        {
            if(gbAC97)
            {
                *VIC1_INTCLEAR          = INT1_AAC;
                gdwInterruptMask1       &= ~INT1_AAC;
            }
            else
            {
                *VIC2_INTCLEAR          = INT2_SAI;
                gdwInterruptMask2       &= ~INT2_SAI;
            }
        }
        sPlayBack.bEnabled      = FALSE;
        sPlayBack.bIntEnabled   = FALSE;
    }

    if(idInt == SYSINTR_PIO_RECORD )
    {
        if(!sPlayBack.bIntEnabled)
        {
            if(gbAC97)
            {
                *VIC1_INTCLEAR          = INT1_AAC;
                gdwInterruptMask1       &= ~INT1_AAC;
            }
            else
            {
                *VIC2_INTCLEAR          = INT2_SAI;
                gdwInterruptMask2       &= ~INT2_SAI;
            }
        }
        sRecord.bEnabled        = FALSE;
        sRecord.bIntEnabled     = FALSE;
    }

#ifdef EDB9315A_CIR
	if(idInt == SYSINTR_PIO_CIR )
	{
		// Initialize EGPIO13 for CIR interrupt.
		UINT value;

	    //OEMWriteDebugByte('D');
	    //OEMWriteDebugByte('\r');
	    //OEMWriteDebugByte('\n');
	    
		value = *GPIO_BINTEN;
		value &= ~0x20;	// Disable interrupt.
		*GPIO_BINTEN = value;

		gnWi = 0;
		gnKeyCode = 0;

	}
#endif

    INTERRUPTS_ON();

    return;
}

/*
 * @func   BOOL | OEMInterruptDone | Signal completion of interrupt processing
 *
 * @rdesc  none
 *
 * @parms
 *         idInt   Interrupt ID to be enabled.
 *                 See Interrupt ID's.Interrupt ID's>  for a list of
 *                 possble values.
 *
 * @comm   OEMInterruptDone is called by the Kernel when a device driver
 *         calls InterruptDone(). The system is not preemtible when this
 *         function is called.
 *
 * @xref
 *         Overview.Kernel Interrupt Support
 *         InterruptDone
 */
void OEMInterruptDone(DWORD idInt)
{
    BOOL    bRet = TRUE;
    ULONG   ulIntMask1, ulIntMask2;


    bRet = SysIntrNumToInterruptMask(idInt, &ulIntMask1, &ulIntMask2);

    INTERRUPTS_OFF();

    // NOTE: we expect the interrupt to be turned off at the device.  The
    // state isn't latched in any board-level registers.

    // Enable interrupt.
    //OEMInterruptEnable(idInt, NULL, 0);
    if(idInt == SYSINTR_PIO_PLAYBACK )
    {
        *VIC1_SOFTINTCLEAR  = INT1_UNUSED1;
    }
    if(idInt == SYSINTR_PIO_RECORD )
    {
        *VIC1_SOFTINTCLEAR  = INT1_UNUSED2;
    }
    
#ifdef EDB9315A_CIR
	if(idInt == SYSINTR_PIO_CIR )
	{
		UINT value;
		
	    //OEMWriteDebugByte('N');
	    //OEMWriteDebugByte('\r');
	    //OEMWriteDebugByte('\n');

		//gnWi = 0;
		//gnKeyCode = 0;

		*GPIO_BEOI = 0x20; // Clean previous interrupt

		value = *GPIO_BINTEN;
		value |= 0x20; // Enable interrupt
		*GPIO_BINTEN = value;	
	}
#endif

    if(ulIntMask1)
    {
        *VIC1_INTENABLE     = ulIntMask1;
        // ASSERT(gdwInterruptMask1 & ulIntMask1);
    }

    if(ulIntMask2)
    {
        *VIC2_INTENABLE     = ulIntMask2;
        // ASSERT(gdwInterruptMask2 & ulIntMask2);
    }


    INTERRUPTS_ON();

}

//****************************************************************************
// OEMInitInterrupts
//****************************************************************************
// Initialize the interrupt controller.
// 
//
void OEMInitInterrupts(void )
{
	//
    // Currently, interrupts on generate irq.  No FIQ's are generated.
    //
    *VIC1_INTSELECT     = 0;
    *VIC2_INTSELECT     = 0;

    //
    // Only the timer interrupt will be enabled initially.
    //
    *VIC1_INTCLEAR      = 0xFFFFFFFF;
    *VIC2_INTCLEAR      = 0xFFFFFFFF;

    //
    // Clear all software interrupts.
    //
    *VIC1_SOFTINTCLEAR  = 0xFFFFFFFF;
    *VIC2_SOFTINTCLEAR  = 0xFFFFFFFF;

    //
    // Allow the Vic to be programmed in all modes.
    //
    *VIC1_PROTECTION    = 0;
    *VIC2_PROTECTION    = 0;

    //
    // Even though we are not using the vectored part of the vectored interrupt
    // controller, we must write VECTCURADDR in order to make sure that lower
    // priority interrupts occur.
    //
    // If you don't do these write no interrupts may occur.
    //
    *VIC1_VECTCURADDR = 0;
    *VIC2_VECTCURADDR = 0;

    //
    // Enable the timer interrupt.
    //
    *VIC1_INTENABLE     = INT1_TIMER1;


    //
    // Initialize the PIO Audio Variables to zero.
    //
    sPlayBack.pulBuffer     = (PULONG)gulTransmitBuffer;
    sPlayBack.ulBufferSize  = 0;
    sPlayBack.pulBufferEnd  = 0;
    sPlayBack.pulBufferHalf = 0;
    sPlayBack.pulPosition   = 0;
    sPlayBack.bEnabled      = FALSE;
    sPlayBack.bIntEnabled   = FALSE;


    sRecord.pulBuffer       = (PULONG)gulRecieveBuffer;
    sRecord.ulBufferSize    = 0;
    sRecord.pulBufferEnd    = 0;
    sRecord.pulBufferHalf   = 0;
    sRecord.pulPosition     = 0;
    sRecord.bEnabled        = FALSE;
    sRecord.bIntEnabled     = FALSE;

    gbAC97                  = FALSE; 
}