xsost.c

优龙YLP270开发板 光盘自带的BIOS和实验例程源码 强烈推荐

*
*******************************************************************************
*/
UINT32 XsOstDisableInterrupt(UINT channel)
{
    UINT32 returnValue = 0;
    volatile OSTRegsT *OstControlRegsP = Ost.regsP;
    
    switch (channel)
    {
        case 0:
            OstControlRegsP->OIER &= ~OIER_E0;
            break;
        case 1:
            OstControlRegsP->OIER &= ~OIER_E1;
            break;    
        case 2:
            OstControlRegsP->OIER &= ~OIER_E2;
            break;    
        case 3:
            OstControlRegsP->OIER &= ~OIER_E3;
            break;
        default:
            LOGERROR(returnValue, ERR_L_XSOST, 0, ERR_T_ILLPARAM, 0, 0, 0);
    }

    return returnValue;
}

/*
*******************************************************************************
*
* FUNCTION:         XsOstSetMatchRegister
*
* DESCRIPTION:      Sets a match register to an integer value
*
* INPUT PARAMETERS: UINT - which of the 4 registers
*                   UINT32 - count value
*
* RETURNS:          UINT32 - 0 means success
*
* GLOBAL EFFECTS:   None
*
* ASSUMPTIONS:      None
*
* CALLS:            NOne
*
* CALLED BY:        Anyone
*
* PROTOTYPE:        UINT32 XsOstSetMatchRegister (UINT reg, UINT32 value);
*
*******************************************************************************
*/
UINT32 XsOstSetMatchRegister (UINT reg, UINT32 value)
{
    UINT32 returnValue = 0;
    volatile OSTRegsT *OstControlRegsP = Ost.regsP;
    
    switch (reg)
    {
        case 0:
            OstControlRegsP->OSMR0 = value;
            break;    
        
        case 1:
			printf("This is ANGEL's MATCH register...DO NOT TOUCH!\r\n");
            //OstControlRegsP->OSMR1 = value;
            break;    
        
        case 2:
            OstControlRegsP->OSMR2 = value;
            break;    
        
        case 3:
            OstControlRegsP->OSMR3 = value;
            break;    
        
        default:
            LOGERROR(returnValue, ERR_L_XSOST, 0, ERR_T_ILLPARAM, 0, 0, 0);
            break;
    }

    return returnValue;
}



/*
*******************************************************************************
*
* FUNCTION:         XsOstSetupTimer
*
* DESCRIPTION:      
*
* INPUT PARAMETERS: 
*
* RETURNS:          UINT32 - 0 means no error
*                          - non-0 means no timer is available
*
* GLOBAL EFFECTS:   Allocates a timer for a short period
*
* ASSUMPTIONS:      None
*
* CALLS:            None
*
* CALLED BY:        Anyone
*
* PROTOTYPE:        UINT32 XsOstCallTimer(UINT32, OSTCallBackFnPT, void *);
*
*******************************************************************************
*/

UINT32 XsOstSetupTimer(OSTCallBackFnPT callback, PVOID param)
{
		UINT32 returnValue = 0;
//		char buffer[100] = {'\0'};



		//Attempt to get a free OST channel for use.
		XsOstCurrentChannel = XsOstGetFreeChannel();

		//Register the interrupt handler, callback function, as well as the parameter to pass
		//to this callback function
		switch (XsOstCurrentChannel)
        {
        case 0:
            if (!returnValue)
            {
                returnValue = XsIcRegisterHandler (XSIC_OST_REG0_SGNL, 
                                                   (XsIcL1IntHandlerFnPT)&XsOstInterruptHandler, 0);
            }

			if (!returnValue)
            {
                returnValue = XsIcEnableIrqDeviceInt(XSIC_OST_REG0_SGNL);
                                                   
            }

            break;
        
        case 1:

			//This channel cannot be used since it is being used by the
			//low-level init. code.
			printf("Wrong Channel! This is ANGEL's OST channel...!\r\n");
            
            break;
 
        case 2:
            if (!returnValue)
            {
                returnValue = XsIcRegisterHandler (XSIC_OST_REG2_SGNL, 
                                                   (XsIcL1IntHandlerFnPT)XsOstInterruptHandler,0);
            }

			if (!returnValue)
            {
                returnValue = XsIcEnableIrqDeviceInt(XSIC_OST_REG2_SGNL);
                                                   
            }

            break;
 
        case 3:
            if (!returnValue)
            {
                returnValue = XsIcRegisterHandler (XSIC_OST_REG3_SGNL, 
                                                   (XsIcL1IntHandlerFnPT)XsOstInterruptHandler, 0);
            }

			if (!returnValue)
            {
                returnValue = XsIcEnableIrqDeviceInt(XSIC_OST_REG3_SGNL);
                                                   
            }

            break;
    
        default:
            LOGERROR(returnValue, ERR_L_XSOST, 0, ERR_T_BADRANGE, XsOstCurrentChannel, 0, 0);
            break;
            
        }//end switch

		//Register the callback function and its parameter
		XsOstCbFnCtx[XsOstCurrentChannel].XsOstCallback = callback;
		XsOstCbFnCtx[XsOstCurrentChannel].CallbackParam = param;


	return returnValue;
	
}//end XsOstSetupTimer




/*
*******************************************************************************
*
* FUNCTION:         XsOstCallTimer
*
* DESCRIPTION:      Will find one of the four timers and generate a callback 
*                   when the interrupt is generated. The timer is allocated and
*                   then de-allocated just before making the callback. The client
*                   can send a pointer to a parameter that will be sent back to 
*                   the callback function. 
*
* INPUT PARAMETERS: UINT32 msecs in milliseconds 
*                   OSTCallBackFnPT callback 
*                   void * param
*
* RETURNS:          UINT32 - 0 means no error
*                          - non-0 means no timer is available
*
* GLOBAL EFFECTS:   Allocates a timer for a short period
*
* ASSUMPTIONS:      None
*
* CALLS:            None
*
* CALLED BY:        Anyone
*
* PROTOTYPE:        UINT32 XsOstCallTimer(UINT32 msecs, OSTCallBackFnPT callback, 
*                                      void * param);
*
*******************************************************************************
*/
UINT32 XsOstCallTimer (UINT32 msecs, OSTCallBackFnPT callback, void * param)
{
	UINT32 oscrStartValue;	//Value of the OSCR at the instant at which it is read
	static UINT32 numberOfTicks = 0;
	UINT32 returnValue = 0;
    volatile OSTRegsT *OstControlRegsP = Ost.regsP;



	returnValue = XsOstSetupTimer(callback, param);

	//Compute the equivalent number of ticks,from millisecs
	if(!returnValue)
	{
		numberOfTicks = XsOstComputeTicks(msecs * 1000);
		/*sprintf(buffer, "Number of ticks: %08x",  numberOfTicks);
		DM_Printf(buffer);*/
	}

	//Set the appropriate bit in the OIER. Only when the correct bit is set here,
	//will the corresponding bit be set in the OSSR. The OSSR bit is routed to the
	//Interrupt Controller, These OSSR status bit(s) can then be unmasked
	//to cause a CPU interrupt.
	if (!returnValue)
    {
		//sprintf(buffer, "OIER address: %08x",  &OstControlRegsP->OIER);
		//DM_Printf(buffer);
        returnValue = XsOstEnableInterrupt(XsOstCurrentChannel);
		//sprintf(buffer, "OIER value: %08x",  OstControlRegsP->OIER);
		//DM_Printf(buffer);
    }

	//XsOstNewTest = 0;


	//sprintf(buffer, "OSCR address: %08x",  &OstControlRegsP->OSCR);
	//DM_Printf(buffer);
	//Read the current value of OSCR (i.e. the OS Timer Count Register)
	//and set the appropriate MATCH register.
	if(!returnValue)
	{

	 	oscrStartValue = OstControlRegsP->OSCR;
	 	returnValue = XsOstSetMatchRegister(XsOstCurrentChannel, (oscrStartValue + numberOfTicks));
	}

     //sprintf(buffer, "OSMR0 value: %08x",  OstControlRegsP->OSMR0);
	 //DM_Printf(buffer);

    return returnValue;

}//end XsOstCallTimer



/*
*******************************************************************************
*
* FUNCTION:         XsOstInterruptHandler
*
* DESCRIPTION:      
*                   
*                   
*                   
*                   
*
* INPUT PARAMETERS: UINT32 msecs in milliseconds 
*                   OSTCallBackFnPT callback 
*                   void * param
*
* RETURNS:          UINT32 - 0 means no error
*                          - non-0 means no timer is available
*
* GLOBAL EFFECTS:   Allocates a timer for a short period
*
* ASSUMPTIONS:      None
*
* CALLS:            None
*
* CALLED BY:        Anyone
*
* PROTOTYPE:        UINT32 XsOstCallTimer(UINT32 msecs, OSTCallBackFnPT callback, 
*                                      void * param);
*
*******************************************************************************
*/

void XsOstInterruptHandler()
{
	volatile OSTRegsT *OstControlRegsP = Ost.regsP;
//	UINT32 returnValue = 0;
#ifdef temp
	extern volatile UINT32 XsOstInterruptGenerated;
	extern UINT32 OstTest;
#endif
	//char buffer[100] = {'\0'};


	//sprintf(buffer, "Inside XsOstInterruptHandler");
	//DM_Printf(buffer);

	switch(XsOstCurrentChannel)
	{
	case 0:
		OstControlRegsP->OSSR |= (OSSR_M0);
	break;

	case 1:
		printf("This is ANGEL's Interrupt Handler...! ERROR!!\r\n");
	  //	OstControlRegsP->OSSR |= (OSSR_M1);
	break;

	case 2:
		OstControlRegsP->OSSR |= (OSSR_M2);
	break;

	case 3:
		OstControlRegsP->OSSR |= (OSSR_M3);
	break;

	default:
		 //LOGERROR(0, ERR_L_XSOST, 0, ERR_T_BADRANGE, channel, 0, 0);
		 //Do nothing.
	break;
	}//end switch

//	sprintf(buffer, "After SWITCH");
//	DM_Printf(buffer);

//	sprintf(buffer, "Before Callback");
//	DM_Printf(buffer);

	//Call the callback function
	XsOstCbFnCtx[XsOstCurrentChannel].XsOstCallback(XsOstCbFnCtx[XsOstCurrentChannel].CallbackParam);

  //	sprintf(buffer, "After Callback");
//	DM_Printf(buffer);
#ifdef temp
	XsOstInterruptGenerated = 1;

	if(OstTest == 0)
	{
		//Cleanup and garbage-collection
		returnValue = XsOstCleanupTimer();
	}
#endif
	return;

}//end XsOstInterruptHandler

/*
*******************************************************************************
*
* FUNCTION:         XsOstCleanupTimer
*
* DESCRIPTION:      
*                   
*                   
*                   
*                   
*
* INPUT PARAMETERS: UINT32 msecs in milliseconds 
*                   OSTCallBackFnPT callback 
*                   void * param
*
* RETURNS:          UINT32 - 0 means no error
*                          - non-0 means no timer is available
*
* GLOBAL EFFECTS:   Allocates a timer for a short period
*
* ASSUMPTIONS:      None
*
* CALLS:            None
*
* CALLED BY:        Anyone
*
* PROTOTYPE:        
*
*******************************************************************************
*/

UINT32 XsOstCleanupTimer()
{
	UINT32 returnValue = 0;

	

	switch(XsOstCurrentChannel)
	{
	case 0:
		returnValue = XsIcDisableIrqDeviceInt(XSIC_OST_REG0_SGNL);
		if(!returnValue)
		{
			returnValue = XsIcUnRegisterHandler(XSIC_OST_REG0_SGNL);
		}

	break;

	case 1:
		printf("Cannot Disable interrupt. This is ANGEL's channel...!\r\n");

	break;

	case 2:
		returnValue = XsIcDisableIrqDeviceInt(XSIC_OST_REG2_SGNL);
		if(!returnValue)
		{
			returnValue = XsIcUnRegisterHandler(XSIC_OST_REG2_SGNL);
		}
	break;