csl_mcaspaux.h

Configuring External Interrupts on TMS320C672x Devices

 *   @n This function checks whether receiver overrun flag is set or not
 *
 *   @b Arguments
 *   @verbatim
            hMcasp            Handle to the McASP instance
     @endverbatim
 *
 *   <b> Return Value </b>  Bool
 *   @li                    TRUE  - Receiver overrun flag is set 
 *   
 *   @li                    FALSE - Receiver overrun flag is not set
 *
 *   <b> Pre Condition </b>
 *   @n  None
 *
 *   <b> Post Condition </b>
 *   @n  None
 *
 *   @b Modifies
 *   @n None
 *
 *   @b Example
 *   @verbatim
        Bool    rcvOverRun;
        
        rcvOverRun = CSL_mcaspGetRcvOverrun (hMcasp);
        
     @endverbatim
 * ============================================================================
 */
static inline
Bool CSL_mcaspGetRcvOverrun (
    CSL_McaspHandle    hMcasp    
)
{
	return((Bool)CSL_FEXT(hMcasp->regs->RSTAT, MCASP_RSTAT_ROVRN));
}

/** ===========================================================================
 *   @n@b CSL_mcaspGetRcvDataReady
 *
 *   @b Description
 *   @n This function checks whether receive data ready flag is set or not
 *
 *   @b Arguments
 *   @verbatim
            hMcasp            Handle to the McASP instance
     @endverbatim
 *
 *   <b> Return Value </b>  Bool
 *   @li                    TRUE  - Receive data ready flag is set
 *   
 *   @li                    FALSE - Receive data ready flag is not set
 *
 *   <b> Pre Condition </b>
 *   @n  None
 *
 *   <b> Post Condition </b>
 *   @n  None
 *
 *   @b Modifies
 *   @n None
 *
 *   @b Example
 *   @verbatim
        Bool    rcvDataReady;
        
        rcvDataReady = CSL_mcaspGetRcvDataReady (hMcasp);
        
     @endverbatim
 * ============================================================================
 */
static inline
Bool CSL_mcaspGetRcvDataReady (
    CSL_McaspHandle    hMcasp    
)
{
	return((Bool)CSL_FEXT(hMcasp->regs->RSTAT, MCASP_RSTAT_RDATA));
}

/** ===========================================================================
 *   @n@b CSL_mcaspGetSerRcvReady
 *
 *   @b Description
 *   @n This function checks whether receive buffer ready bit of serializer
 *      control register is set or not
 *
 *   @b Arguments
 *   @verbatim
            hMcasp            Handle to the McASP instance
            
            serRcvReady       Serailizer status will be stored here
            
            serNum            Serailizer register to be checked
     @endverbatim
 *
 *   <b> Return Value </b>  CSL_Status
 *   @li                    CSL_SOK - Command executed successfully 
 *   
 *   @li                    CSL_ESYS_FAIL - If serNum passed is invalid.
 *
 *   <b> Pre Condition </b>
 *   @n  None
 *
 *   <b> Post Condition </b>
 *   @n  None
 *
 *   @b Modifies
 *   @n None
 *
 *   @b Example
 *   @verbatim
        CSL_Status st;
        Bool                    serRcvReady;
        CSL_McaspSerializerNum  serNum = SERIALIZER_1;
        
        st = CSL_mcaspGetSerRcvReady (hMcasp, &serRcvReady, serNum);
        
     @endverbatim
 * ============================================================================
 */
static inline
CSL_Status CSL_mcaspGetSerRcvReady (
    CSL_McaspHandle         hMcasp,
    Bool                    *serRcvReady,
    CSL_McaspSerializerNum  serNum
)
{
	CSL_Status st = CSL_SOK;

	switch (serNum) 
	{
		case SERIALIZER_1:
			*(Bool *)serRcvReady = ((Bool)CSL_FEXT(hMcasp->regs->SRCTL0,
			MCASP_SRCTL0_RRDY));
			break;
		case SERIALIZER_2:
			*(Bool *)serRcvReady = ((Bool)CSL_FEXT(hMcasp->regs->SRCTL1,
			MCASP_SRCTL1_RRDY));
			break;
		case SERIALIZER_3:
			*(Bool *)serRcvReady = ((Bool)CSL_FEXT(hMcasp->regs->SRCTL2,
			MCASP_SRCTL2_RRDY));
			break;
		case SERIALIZER_4:
			*(Bool *)serRcvReady = ((Bool)CSL_FEXT(hMcasp->regs->SRCTL3,
			MCASP_SRCTL3_RRDY));
			break;
		case SERIALIZER_5:
			*(Bool *)serRcvReady = ((Bool)CSL_FEXT(hMcasp->regs->SRCTL4,
			MCASP_SRCTL4_RRDY));
			break;
		case SERIALIZER_6:
			*(Bool *)serRcvReady = ((Bool)CSL_FEXT(hMcasp->regs->SRCTL5,
			MCASP_SRCTL5_RRDY));
			break;
		case SERIALIZER_7:
			*(Bool *)serRcvReady = ((Bool)CSL_FEXT(hMcasp->regs->SRCTL6,
			MCASP_SRCTL6_RRDY));
			break;
		case SERIALIZER_8:
			*(Bool *)serRcvReady = ((Bool)CSL_FEXT(hMcasp->regs->SRCTL7,
			MCASP_SRCTL7_RRDY));
			break;
		case SERIALIZER_9:
			*(Bool *)serRcvReady = ((Bool)CSL_FEXT(hMcasp->regs->SRCTL8,
			MCASP_SRCTL8_RRDY));
			break;
		case SERIALIZER_10:
			*(Bool *)serRcvReady = ((Bool)CSL_FEXT(hMcasp->regs->SRCTL9,
			MCASP_SRCTL9_RRDY));
			break;
		case SERIALIZER_11:
			*(Bool *)serRcvReady = ((Bool)CSL_FEXT(hMcasp->regs->SRCTL10,
			MCASP_SRCTL10_RRDY));
			break;
		case SERIALIZER_12:
			*(Bool *)serRcvReady = ((Bool)CSL_FEXT(hMcasp->regs->SRCTL11,
			MCASP_SRCTL11_RRDY));
			break;
		case SERIALIZER_13:
			*(Bool *)serRcvReady = ((Bool)CSL_FEXT(hMcasp->regs->SRCTL12,
			MCASP_SRCTL12_RRDY));
			break;
		case SERIALIZER_14:
			*(Bool *)serRcvReady = ((Bool)CSL_FEXT(hMcasp->regs->SRCTL13,
			MCASP_SRCTL13_RRDY));
			break;
		case SERIALIZER_15:
			*(Bool *)serRcvReady = ((Bool)CSL_FEXT(hMcasp->regs->SRCTL14,
			MCASP_SRCTL14_RRDY));
			break;
		case SERIALIZER_16:
			*(Bool *)serRcvReady = ((Bool)CSL_FEXT(hMcasp->regs->SRCTL15,
			MCASP_SRCTL15_RRDY));
			break;
		default:
			st = CSL_ESYS_FAIL;
	}
	return st;
}

/** ===========================================================================
 *   @n@b CSL_mcaspGetSerXmtReady
 *
 *   @b Description
 *   @n This function checks whether transmit buffer ready bit of serializer
 *      control register is set or not
 *
 *   @b Arguments
 *   @verbatim
            hMcasp            Handle to the McASP instance
            
            serXmtReady       Status of the serializer will be stored here
            
            serNum            Serailizer register to be checked
     @endverbatim
 *
 *   <b> Return Value </b>  CSL_Status
 *   @li                    CSL_SOK - Command executed successfully
 *   
 *   @li                    CSL_ESYS_FAIL - If serNum passed is invalid.
 *
 *   <b> Pre Condition </b>
 *   @n  None
 *
 *   <b> Post Condition </b>
 *   @n  None
 *
 *   @b Modifies
 *   @n None
 *
 *   @b Example
 *   @verbatim
        CSL_Status st;
        Bool    serXmtReady;
        CSL_McaspSerializerNum   serNum = SERIALIZER_1;
        
        st = CSL_mcaspGetSerXmtReady (hMcasp, &serXmtReady, serNum);
        
     @endverbatim
 * ============================================================================
 */
static inline
CSL_Status CSL_mcaspGetSerXmtReady (
    CSL_McaspHandle         hMcasp,
    Bool                    *serXmtReady,
    CSL_McaspSerializerNum  serNum
)
{
	CSL_Status st = CSL_SOK;

	switch (serNum) 
	{
		case SERIALIZER_1:
			*(Bool *)serXmtReady = ((Bool)CSL_FEXT(hMcasp->regs->SRCTL0, 
			MCASP_SRCTL0_XRDY));
			break;

		case SERIALIZER_2:
			*(Bool *)serXmtReady = ((Bool)CSL_FEXT(hMcasp->regs->SRCTL1, 
			MCASP_SRCTL1_XRDY));
			break;

		case SERIALIZER_3:
			*(Bool *)serXmtReady = ((Bool)CSL_FEXT(hMcasp->regs->SRCTL2, 
			MCASP_SRCTL2_XRDY));
			break;

		case SERIALIZER_4:
			*(Bool *)serXmtReady = ((Bool)CSL_FEXT(hMcasp->regs->SRCTL3, 
			MCASP_SRCTL3_XRDY));
			break;

		case SERIALIZER_5:
			*(Bool *)serXmtReady = ((Bool)CSL_FEXT(hMcasp->regs->SRCTL4, 
			MCASP_SRCTL4_XRDY));
			break;

		case SERIALIZER_6:
			*(Bool *)serXmtReady = ((Bool)CSL_FEXT(hMcasp->regs->SRCTL5, 
			MCASP_SRCTL5_XRDY));
			break;

		case SERIALIZER_7:
			*(Bool *)serXmtReady = ((Bool)CSL_FEXT(hMcasp->regs->SRCTL6, 
			MCASP_SRCTL0_XRDY));
			break;

		case SERIALIZER_8:
			*(Bool *)serXmtReady = ((Bool)CSL_FEXT(hMcasp->regs->SRCTL7, 
			MCASP_SRCTL0_XRDY));
			break;

		case SERIALIZER_9:
			*(Bool *)serXmtReady = ((Bool)CSL_FEXT(hMcasp->regs->SRCTL8, 
			MCASP_SRCTL0_XRDY));
			break;

		case SERIALIZER_10:
			*(Bool *)serXmtReady = ((Bool)CSL_FEXT(hMcasp->regs->SRCTL9, 
			MCASP_SRCTL0_XRDY));
			break;

		case SERIALIZER_11:
			*(Bool *)serXmtReady = ((Bool)CSL_FEXT(hMcasp->regs->SRCTL10, 
			MCASP_SRCTL0_XRDY));
			break;

		case SERIALIZER_12:
			*(Bool *)serXmtReady = ((Bool)CSL_FEXT(hMcasp->regs->SRCTL11, 
			MCASP_SRCTL0_XRDY));
			break;

		case SERIALIZER_13:
			*(Bool *)serXmtReady = ((Bool)CSL_FEXT(hMcasp->regs->SRCTL12, 
			MCASP_SRCTL0_XRDY));
			break;

		case SERIALIZER_14:
			*(Bool *)serXmtReady = ((Bool)CSL_FEXT(hMcasp->regs->SRCTL13, 
			MCASP_SRCTL0_XRDY));
			break;

		case SERIALIZER_15:
			*(Bool *)serXmtReady = ((Bool)CSL_FEXT(hMcasp->regs->SRCTL14, 
			MCASP_SRCTL0_XRDY));
			break;

		case SERIALIZER_16:
			*(Bool *)serXmtReady = ((Bool)CSL_FEXT(hMcasp->regs->SRCTL15, 
			MCASP_SRCTL0_XRDY));
			break;

		default:
			st = CSL_ESYS_FAIL;
	}
	return st;
}

/** ===========================================================================
 *   @n@b CSL_mcaspGetSerMode
 *
 *   @b Description
 *   @n This function gets the serializer mode
 *
 *   @b Arguments
 *   @verbatim
            hMcasp            Handle to the McASP instance
            
            serMode           Serializer mode will be here
            
            serNum            Serailizer register to be checked
     @endverbatim
 *
 *   <b> Return Value </b>  CSL_Status
 *   @li                    CSL_SOK - Command executed successfully
 *   
 *   @li                    CSL_ESYS_FAIL - If serNum passed is invalid.
 *
 *   <b> Pre Condition </b>
 *   @n  None
 *
 *   <b> Post Condition </b>
 *   @n  None
 *
 *   @b Modifies
 *   @n  None
 *
 *   @b Example
 *   @verbatim
        CSL_Status = st;
        CSL_McaspSerMode   serMode;
        CSL_McaspSerializerNum   serNum = SERIALIZER_1;
        
        st = CSL_mcaspGetSerMode (hMcasp, serMode, serNum);
        
     @endverbatim
 * ============================================================================
 */
static inline
CSL_Status CSL_mcaspGetSerMode (
    CSL_McaspHandle         hMcasp,
    CSL_McaspSerMode        *serMode,
    CSL_McaspSerializerNum  serNum
)
{
	CSL_Status st = CSL_SOK;

	switch (serNum) 
	{
		case SERIALIZER_1:
			*(CSL_McaspSerMode *)serMode = ((CSL_McaspSerMode)
			CSL_FEXT (hMcasp->regs->SRCTL0,
			MCASP_SRCTL0_SRMOD));
			break;
		case SERIALIZER_2:
			*(CSL_McaspSerMode *)serMode = ((CSL_McaspSerMode)
			CSL_FEXT(hMcasp->regs->SRCTL1,
			MCASP_SRCTL1_SRMOD));
			break;
		case SERIALIZER_3:
			*(CSL_McaspSerMode *)serMode = ((CSL_McaspSerMode)
			CSL_FEXT(hMcasp->regs->SRCTL2, 
			MCASP_SRCTL2_SRMOD));
			break;
		case SERIALIZER_4:
			*(CSL_McaspSerMode *)serMode = ((CSL_McaspSerMode)
			CSL_FEXT(hMcasp->regs->SRCTL3, 
			MCASP_SRCTL3_SRMOD));
			break;
		case SERIALIZER_5:
			*(CSL_McaspSerMode *)serMode = ((CSL_McaspSerMode)
			CSL_FEXT(hMcasp->regs->SRCTL4, 
			MCASP_SRCTL4_SRMOD));
			break;
		case SERIALIZER_6:
			*(CSL_McaspSerMode *)serMode = ((CSL_McaspSerMode)
			CSL_FEXT(hMcasp->regs->SRCTL5, 
			MCASP_SRCTL5_SRMOD));
			break;
		case SERIALIZER_7:
			*(CSL_McaspSerMode *)serMode = ((CSL_McaspSerMode)
			CSL_FEXT(hMcasp->regs->SRCTL6, 
			MCASP_SRCTL6_SRMOD));
			break;
		case SERIALIZER_8:
			*(CSL_McaspSerMode *)serMode = ((CSL_McaspSerMode)
			CSL_FEXT(hMcasp->regs->SRCTL7, 
			MCASP_SRCTL7_SRMOD));
			break;
		case SERIALIZER_9:
			*(CSL_McaspSerMode *)serMode = ((CSL_McaspSerMode)
			CSL_FEXT(hMcasp->regs->SRCTL8, 
			MCASP_SRCTL8_SRMOD));
			break;
		case SERIALIZER_10:
			*(CSL_McaspSerMode *)serMode = ((CSL_McaspSerMode)
			CSL_FEXT(hMcasp->regs->SRCTL9, 
			MCASP_SRCTL9_SRMOD));
			break;
		case SERIALIZER_11:
			*(CSL_McaspSerMode *)serMode = ((CSL_McaspSerMode)
			CSL_FEXT(hMcasp->regs->SRCTL10, 
			MCASP_SRCTL10_SRMOD));
			break;
		case SERIALIZER_12:
			*(CSL_McaspSerMode *)serMode = ((CSL_McaspSerMode)
			CSL_FEXT(hMcasp->regs->SRCTL11, 
			MCASP_SRCTL11_SRMOD));
			break;
		case SERIALIZER_13:
			*(CSL_McaspSerMode *)serMode = ((CSL_McaspSerMode)
			CSL_FEXT(hMcasp->regs->SRCTL12, 
			MCASP_SRCTL12_SRMOD));
			break;
		case SERIALIZER_14:
			*(CSL_McaspSerMode *)serMode = ((CSL_McaspSerMode)
			CSL_FEXT(hMcasp->regs->SRCTL13, 
			MCASP_SRCTL13_SRMOD));
			break;
		case SERIALIZER_15:
			*(CSL_McaspSerMode *)serMode = ((CSL_McaspSerMode)
			CSL_FEXT(hMcasp->regs->SRCTL14, 
			MCASP_SRCTL14_SRMOD));
			break;
		case SERIALIZER_16:
			*(CSL_McaspSerMode *)serMode = ((CSL_McaspSerMode)
			CSL_FEXT(hMcasp->regs->SRCTL15, 
			MCASP_SRCTL15_SRMOD));