xllp_msl.c

PXA270硬件测试源代码

    if(fifoService != XLLP_FIFO_SERVICE_NONE)
	    bitsToSet=   (fifoService << XLLP_MSL_BBCFG_RxService);
    else
	    bitsToClear= (0x7U << XLLP_MSL_BBCFG_RxService);

	XLLP_CLEAR_BITS(channelCfg, bitsToClear);
    XLLP_SET_BITS  (channelCfg, bitsToSet);
	pMslRegBase->ConfigReg.BBCFG[channel] = channelCfg;
}

//******************************************************************************
// XLLP_DOC_HDR_BEGIN
//
// Function Name:     XllpMslGetChannelStatus
//
// Description:       XllpMslGetChannelStatus retrieves the status of the specified channel. 
//                    The status of both the Transmit and Receive operations is received  
//  
// Registers Modified:  BBSTATx is accessed
//
// Input Arguments:
//  pMslRegBase         Pointer to base MSL register map
//  channel:            MSL channel 
//
// Output Arguments:
//  status:             Channel status
//    
// Return Value: 
//
// XLLP_DOC_HDR_END
//*******************************************************************************
void XllpMslGetChannelStatus  
( 
	P_XllpMslRegT				pMslRegBase,
	XLLP_INT32_T				channel,
	XLLP_UINT32_T				*status
)
{
	*status = pMslRegBase->StatusReg.BBSTAT[channel];
	return;
}

//******************************************************************************
// XLLP_DOC_HDR_BEGIN
//
// Function Name:       XllpMslGetInterruptStatus
//
// Description:         XllpMslGetInterruptStatus retrieves status information about interrupts 
//                      asserted. 
//                      The status for both the Transmit and Receive operations is received.
//  
// Registers Modified:  BBIID is acessed
//
// Input Arguments:
//  pMslRegBase         Pointer to base MSL register map
//
// Output Arguments:
//  interruptStatus:        
//
// Return Value: 
//
// XLLP_DOC_HDR_END
//*******************************************************************************
void XllpMslGetInterruptStatus
(
	P_XllpMslRegT				pMslRegBase,
	XLLP_UINT32_T				*interruptStatus
)
{
	*interruptStatus = pMslRegBase->ControlReg.BBIID;
	return;
}

//******************************************************************************
// XLLP_DOC_HDR_BEGIN
//
// Function Name:       XllpMslClearInterrupts	  
//
// Description:         XllpMslClearInterruptStatus clears asserted interrupts.
//  
// Registers Modified:  BBIID
//
// Input Arguments:
//  pMslRegBase         Pointer to base MSL register map
//  interruptMask       Specifies the interrupts to clear. Is a bit mask for BBIID register.
//
// Output Arguments:
//
// Return Value: 
//
// XLLP_DOC_HDR_END
//*******************************************************************************
void XllpMslClearInterrupts	  
(
	P_XllpMslRegT				pMslRegBase,
	XLLP_UINT32_T				interruptMask
)
{
	pMslRegBase->ControlReg.BBIID = interruptMask;
	return;
}

//******************************************************************************
// XLLP_DOC_HDR_BEGIN
//
// Function Name:       XllpMslSendWake		   
//
// Description:         XllpMslSendWake sends a bus wake up command to the remote node.
//  
// Registers Modified:  BBWAKE
//
// Input Arguments:
//  pMslRegBase         Pointer to base MSL register map
//
// Output Arguments:
//
// Return Value: 
//
// XLLP_DOC_HDR_END
//*******************************************************************************
void XllpMslSendWake		   
(
	P_XllpMslRegT				pMslRegBase 
)
{
	//
	// Write anything to WAKE register 
	//
	pMslRegBase->ControlReg.BBWAKE = XLLP_SET;
	return;
}

//******************************************************************************
// XLLP_DOC_HDR_BEGIN
//
// Function Name:       XllpMslSendEOM			   
//
// Description:         XllpMslSendEom sends an end of message command to the remote node.
//  
// Registers Modified:  BBEOMx
//
// Input Arguments:
//  pMslRegBase         Pointer to base MSL register map
//  channel:            MSL ouybound link TX channel number
//
// Output Arguments:
//
// Return Value: 
//
// XLLP_DOC_HDR_END
//*******************************************************************************
void XllpMslSendEOM			   
(
	P_XllpMslRegT				pMslRegBase,
	XLLP_UINT32_T				channel
)
{
	//
	// Write anything to EOM register for this particular channel
	//
	pMslRegBase->EomReg.BBEOM[channel] = XLLP_SET;
	return;
}

//******************************************************************************
// XLLP_DOC_HDR_BEGIN
//
// Function Name:       XllpMslGetVgpioLevel	   
//
// Description:         XllpMslGetVgpioLevel retrieves the level of the specified 
//                      VGPIO pin.
//  
// Registers Modified:  BBVGIL, BBVGOL
//
// Input Arguments:
//  pMslRegBase         Pointer to base MSL register map
//  pinType             Input or Output
//  pinNumber           Pin number
//
// Output Arguments:
//
// Return Value: 
//  pinLevel            Level of pin.
//
// XLLP_DOC_HDR_END
//*******************************************************************************
XLLP_LEVEL_T XllpMslGetVgpioLevel	   
(
	P_XllpMslRegT				pMslRegBase,
	XllpVgpioPinTypeT			pinType,
	XLLP_UINT32_T				pinNumber
)
{
	XLLP_LEVEL_T				pinLevel;

	if (pinType == OutputVgpioPin)
	{
		pinLevel = ((pMslRegBase->ControlReg.BBVGOL) & (1 << pinNumber)) ? XLLP_HI : XLLP_LO;
	}
	else
	{
		pinLevel = ((pMslRegBase->ControlReg.BBVGIL) & (1 << pinNumber)) ? XLLP_HI : XLLP_LO;
	}
	return (pinLevel);
}

//******************************************************************************
// XLLP_DOC_HDR_BEGIN
//
// Function Name:       XllpMslSetVgpioLevel	   
//
// Description:         XllpMslSetVgpioLevel sets the level of the specified 
//                      VGPIO pin on the output port.
//  
// Registers Modified:  BBVGSR, BBVGCR
//
// Input Arguments:
//  pMslRegBase         Pointer to base MSL register map
//  pinNumber:          VGPIO pin number
//  pinLevel:           VGPIO pin level
//
// Output Arguments:
//
// Return Value: 
//
// XLLP_DOC_HDR_END
//*******************************************************************************
void XllpMslSetVgpioLevel	   
(
	P_XllpMslRegT				pMslRegBase,
	XLLP_UINT32_T				pinNumber,
	XLLP_LEVEL_T				pinLevel
)
{
	if (pinNumber >= XLLP_MSL_MAX_VGPIO_PINS)
		return;

	if (pinLevel == XLLP_HI)
	  pMslRegBase->ControlReg.BBVGSR  = (1 << pinNumber);
	else
	  pMslRegBase->ControlReg.BBVGCR  = (1 << pinNumber);

	return;
}

//******************************************************************************
// XLLP_DOC_HDR_BEGIN
//
// Function Name:       XllpMslConfigureVgpioEdgeDetect
//
// Description:         XllpMslConfigureVgpioEdgeDetect configures the VGPIO pin so 
//                      that a rising edge or a falling edge transition can be detected.
//  
// Registers Modified:  BBVGRE, BBVGFE
//
// Input Arguments:
//  pMslRegBase         Pointer to base MSL register map
//  pinNumber           VGPIO pin number
//  pinEdgeType         Edge type for the VGPIO pin
//
// Output Arguments:
//
// Return Value: 
//
// XLLP_DOC_HDR_END
//*******************************************************************************						  
void XllpMslConfigureVgpioEdgeDetect
(
	P_XllpMslRegT			pMslRegBase,
	XLLP_UINT32_T			pinNumber,
	XllpMslVgpioEdgeTypeT	pinEdgeType
)
{
	//
	// First clear current settings
	//
	pMslRegBase->ControlReg.BBVGRE = pMslRegBase->ControlReg.BBVGRE & (~(1 << pinNumber));
	pMslRegBase->ControlReg.BBVGFE = pMslRegBase->ControlReg.BBVGFE & (~(1 << pinNumber));

	if (pinEdgeType == VgpioRisingEdge)
	{
	  pMslRegBase->ControlReg.BBVGRE = pMslRegBase->ControlReg.BBVGRE | (1 << pinNumber);
	}
	else if (pinEdgeType == VgpioFallingEdge)
	{
	  pMslRegBase->ControlReg.BBVGFE = pMslRegBase->ControlReg.BBVGFE | (1 << pinNumber);
	}
	else if (pinEdgeType == VgpioRisingAndFallingEdge)
	{
	  pMslRegBase->ControlReg.BBVGRE = pMslRegBase->ControlReg.BBVGRE | (1 << pinNumber);
	  pMslRegBase->ControlReg.BBVGFE = pMslRegBase->ControlReg.BBVGFE | (1 << pinNumber);
	}

	return;
}

//******************************************************************************
// XLLP_DOC_HDR_BEGIN
//
// Function Name:       XllpMslGetVgpioEdgeStatus 
//
// Description:         XllpMslGetVgpioEdgeDetectStatus gets the status of edge 
//                      transition for the specified VGPIO pin.
//  
// Registers Modified:  BBVGED
//
// Input Arguments:
//  pMslRegBase         Pointer to base MSL register map
//  inputPinNumber      Number of input pin
//
// Output Arguments:
//  status:             Specifies whether a configured edge transition occurred or not.
//
// Return Value: 
//
// XLLP_DOC_HDR_END
//*******************************************************************************
XLLP_BOOL_T XllpMslGetVgpioEdgeStatus 
(
	P_XllpMslRegT				pMslRegBase,
	XLLP_UINT32_T				inputPinNumber
)
{
	XLLP_BOOL_T	status;

    if (pMslRegBase->ControlReg.BBVGED & (1 << inputPinNumber))
	{
		status = XLLP_TRUE;	
		pMslRegBase->ControlReg.BBVGED = (1 << inputPinNumber);	// clear status
	}
	else
		status = XLLP_FALSE;

	return (status);
}

//******************************************************************************
// XLLP_DOC_HDR_BEGIN
//
// Function Name:   XllpMslConfigureVgpioInterrupt
//
// Description:     XllpMslConfigureVgpioInterrupt configures the VGPIO pin so that 
//                  an interrupt occurs whenever a value is received across the inbound 
//                  link. The interrupt is caused regardless of whether the VGPIO 
//                  value has changed or not.
//  
// Registers Modified:  BBVGVI
//
// Input Arguments:
//  pMslRegBase         Pointer to base MSL register map
//  offOrOn:            Flag specifying whether interrupts are to be enabled or disabled
//
// Output Arguments:
//
// Return Value: 
//
// XLLP_DOC_HDR_END
//*******************************************************************************
void XllpMslConfigureVgpioInterrupt
(
	P_XllpMslRegT			pMslRegBase,
	XLLP_CONTROL_T			offOrOn
)
{
    pMslRegBase->ControlReg.BBVGVI = (offOrOn & 0x1);
	return;
}