/**
*
* Callback function (called from interrupt handler) to handle frames received in
* interrupt mode. This function is called once per frame received.
* The driver's receive function is called to read the frame from RX FIFO.
*
* @param CallBackRef is the callback reference passed from the interrupt
* handler, which in our case is a pointer to the device instance.
*
* @return None.
*
* @note This function is called by the driver within interrupt context.
*
******************************************************************************/
static void RecvHandler(void *CallBackRef)
{
XCanPs *CanPtr = (XCanPs *)CallBackRef;
int Status;
int Index;
u8 *FramePtr;
Status = XCanPs_Recv(CanPtr, RxFrame);
if (Status != XST_SUCCESS) {
LoopbackError = TRUE;
RecvDone = TRUE;
return;
}
/*
* Verify Identifier and Data Length Code.
*/
if (RxFrame[0] != (u32)XCanPs_CreateIdValue((u32)TEST_MESSAGE_ID, 0, 0, 0, 0)) {
LoopbackError = TRUE;
RecvDone = TRUE;
return;
}
if ((RxFrame[1] & ~XCANPS_DLCR_TIMESTAMP_MASK) != TxFrame[1]) {
LoopbackError = TRUE;
RecvDone = TRUE;
return;
}
/*
* Verify the Data field contents.
*/
FramePtr = (u8 *)(&RxFrame[2]);
for (Index = 0; Index < FRAME_DATA_LENGTH; Index++) {
if (*FramePtr++ != (u8)Index) {
LoopbackError = TRUE;
break;
}
}
RecvDone = TRUE;
}
/**
*
* This function receives a frame and verifies its contents.
*
* @param InstancePtr is a pointer to the driver instance.
*
* @return XST_SUCCESS if successful, a driver-specific return code if not.
*
* @note
*
* This function waits until RX FIFO becomes not empty before reading a frame
* from it. So this function may block if the hardware is not built
* correctly.
*
******************************************************************************/
static int RecvFrame(XCanPs *InstancePtr)
{
u8 *FramePtr;
int Status;
int Index;
/*
* Wait until a frame is received.
*/
while (XCanPs_IsRxEmpty(InstancePtr) == TRUE);
/*
* Receive a frame and verify its contents.
*/
Status = XCanPs_Recv(InstancePtr, RxFrame);
if (Status == XST_SUCCESS) {
/*
* Verify Identifier and Data Length Code.
*/
if (RxFrame[0] !=
(u32)XCanPs_CreateIdValue((u32)TEST_MESSAGE_ID, 0, 0, 0, 0))
return XST_LOOPBACK_ERROR;
if ((RxFrame[1] & ~XCANPS_DLCR_TIMESTAMP_MASK) != TxFrame[1])
return XST_LOOPBACK_ERROR;
/*
* Verify Data field contents.
*/
FramePtr = (u8 *)(&RxFrame[2]);
for (Index = 0; Index < FRAME_DATA_LENGTH; Index++) {
if (*FramePtr++ != (u8)Index) {
return XST_LOOPBACK_ERROR;
}
}
}
return Status;
}
/**
*
* Send a CAN frame.
*
* @param InstancePtr is a pointer to the driver instance
*
* @return XST_SUCCESS if successful, a driver-specific return code if not.
*
* @note
*
* This function waits until TX FIFO has room for at least one frame before
* sending a frame. So this function may block if the hardware is not built
* correctly.
*
******************************************************************************/
static int SendFrame(XCanPs *InstancePtr)
{
u8 *FramePtr;
int Index;
int Status;
/*
* Create correct values for Identifier and Data Length Code Register.
*/
TxFrame[0] = (u32)XCanPs_CreateIdValue((u32)TEST_MESSAGE_ID, 0, 0, 0, 0);
TxFrame[1] = (u32)XCanPs_CreateDlcValue((u32)FRAME_DATA_LENGTH);
/*
* Now fill in the data field with known values so we can verify them
* on receive.
*/
FramePtr = (u8 *)(&TxFrame[2]);
for (Index = 0; Index < FRAME_DATA_LENGTH; Index++) {
*FramePtr++ = (u8)Index;
}
/*
* Wait until TX FIFO has room.
*/
while (XCanPs_IsTxFifoFull(InstancePtr) == TRUE);
/*
* Now send the frame.
*
* Another way to send a frame is keep calling XCanPs_Send() until it
* returns XST_SUCCESS. No check on if TX FIFO is full is needed anymore
* in that case.
*/
Status = XCanPs_Send(InstancePtr, TxFrame);
return Status;
}
/**
*
* Send a CAN frame.
*
* @param InstancePtr is a pointer to the driver instance.
*
* @return None.
*
* @note None.
*
******************************************************************************/
static void SendFrame(XCanPs *InstancePtr)
{
u8 *FramePtr;
int Index;
int Status;
/*
* Create correct values for Identifier and Data Length Code Register.
*/
TxFrame[0] = (u32)XCanPs_CreateIdValue((u32)TEST_MESSAGE_ID, 0, 0, 0, 0);
TxFrame[1] = (u32)XCanPs_CreateDlcValue((u32)FRAME_DATA_LENGTH);
/*
* Now fill in the data field with known values so we can verify them
* on receive.
*/
FramePtr = (u8 *)(&TxFrame[2]);
for (Index = 0; Index < FRAME_DATA_LENGTH; Index++) {
*FramePtr++ = (u8)Index;
}
/*
* Now wait until the TX FIFO is not full and send the frame.
*/
while (XCanPs_IsTxFifoFull(InstancePtr) == TRUE);
Status = XCanPs_Send(InstancePtr, TxFrame);
if (Status != XST_SUCCESS) {
/*
* The frame could not be sent successfully.
*/
LoopbackError = TRUE;
SendDone = TRUE;
RecvDone = TRUE;
}
}
/**
*
* This function runs a self-test on the CAN driver/device. The test resets
* the device, sets up the Loop Back mode, sends a standard frame, receives the
* frame, verifies the contents, and resets the device again.
*
* Note that this is a destructive test in that resets of the device are
* performed. Refer the device specification for the device status after
* the reset operation.
*
*
* @param InstancePtr is a pointer to the XCanPs instance.
*
* @return
* - XST_SUCCESS if the self-test passed. i.e., the frame
* received via the internal loop back has the same contents as
* the frame sent.
* - XST_FAILURE Otherwise.
*
* @note
*
* If the CAN device does not work properly, this function may enter an
* infinite loop and will never return to the caller.
* <br><br>
* If XST_FAILURE is returned, the device is not reset so that the caller could
* have a chance to check reason(s) causing the failure.
*
******************************************************************************/
s32 XCanPs_SelfTest(XCanPs *InstancePtr)
{
u8 *FramePtr;
s32 Status;
u32 Index;
u8 GetModeResult;
u32 RxEmptyResult;
Xil_AssertNonvoid(InstancePtr != NULL);
Xil_AssertNonvoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY);
XCanPs_Reset(InstancePtr);
/*
* The device should enter Configuration Mode immediately after
* reset above is finished. Now check the mode and return error code if
* it is not Configuration Mode.
*/
if (XCanPs_GetMode(InstancePtr) != XCANPS_MODE_CONFIG) {
Status = XST_FAILURE;
return Status;
}
/*
* Setup Baud Rate Prescaler Register (BRPR) and Bit Timing Register
* (BTR) such that CAN baud rate equals 40Kbps, given the CAN clock
* equal to 24MHz. For more information see the CAN 2.0A, CAN 2.0B,
* ISO 11898-1 specifications.
*/
(void)XCanPs_SetBaudRatePrescaler(InstancePtr, (u8)29U);
(void)XCanPs_SetBitTiming(InstancePtr, (u8)3U, (u8)2U, (u8)15U);
/*
* Enter the loop back mode.
*/
XCanPs_EnterMode(InstancePtr, XCANPS_MODE_LOOPBACK);
GetModeResult = XCanPs_GetMode(InstancePtr);
while (GetModeResult != ((u8)XCANPS_MODE_LOOPBACK)) {
GetModeResult = XCanPs_GetMode(InstancePtr);
}
/*
* Create a frame to send with known values so we can verify them
* on receive.
*/
TxFrame[0] = (u32)XCanPs_CreateIdValue((u32)2000U, (u32)0U, (u32)0U, (u32)0U, (u32)0U);
TxFrame[1] = (u32)XCanPs_CreateDlcValue((u32)8U);
FramePtr = (u8 *)((void *)(&TxFrame[2]));
for (Index = 0U; Index < 8U; Index++) {
if(*FramePtr != 0U) {
*FramePtr = (u8)Index;
*FramePtr++;
}
}
/*
* Send the frame.
*/
Status = XCanPs_Send(InstancePtr, TxFrame);
if (Status != (s32)XST_SUCCESS) {
Status = XST_FAILURE;
return Status;
}
/*
* Wait until the frame arrives RX FIFO via internal loop back.
*/
RxEmptyResult = XCanPs_ReadReg(((InstancePtr)->CanConfig.BaseAddr),
XCANPS_ISR_OFFSET) & XCANPS_IXR_RXNEMP_MASK;
while (RxEmptyResult == (u32)0U) {
RxEmptyResult = XCanPs_ReadReg(((InstancePtr)->CanConfig.BaseAddr),
XCANPS_ISR_OFFSET) & XCANPS_IXR_RXNEMP_MASK;
}
/*
* Receive the frame.
*/
Status = XCanPs_Recv(InstancePtr, RxFrame);
if (Status != (s32)XST_SUCCESS) {
Status = XST_FAILURE;
return Status;
}
/*
* Verify Identifier and Data Length Code.
*/
if (RxFrame[0] !=
(u32)XCanPs_CreateIdValue((u32)2000U, (u32)0U, (u32)0U, (u32)0U, (u32)0U)) {
Status = XST_FAILURE;
return Status;
}
if ((RxFrame[1] & ~XCANPS_DLCR_TIMESTAMP_MASK) != TxFrame[1]) {
Status = XST_FAILURE;
return Status;
}
for (Index = 2U; Index < (XCANPS_MAX_FRAME_SIZE_IN_WORDS); Index++) {
if (RxFrame[Index] != TxFrame[Index]) {
Status = XST_FAILURE;
return Status;
}
}
/*
* Reset device again before returning to the caller.
*/
XCanPs_Reset(InstancePtr);
Status = XST_SUCCESS;
return Status;
}
/**
*
* This function runs a self-test on the CAN driver/device. The test resets
* the device, sets up the Loop Back mode, sends a standard frame, receives the
* frame, verifies the contents, and resets the device again.
*
* Note that this is a destructive test in that resets of the device are
* performed. Refer the device specification for the device status after
* the reset operation.
*
*
* @param InstancePtr is a pointer to the XCanPs instance.
*
* @return
* - XST_SUCCESS if the self-test passed. i.e., the frame
* received via the internal loop back has the same contents as
* the frame sent.
* - XST_FAILURE Otherwise.
*
* @note
*
* If the CAN device does not work properly, this function may enter an
* infinite loop and will never return to the caller.
* <br><br>
* If XST_FAILURE is returned, the device is not reset so that the caller could
* have a chance to check reason(s) causing the failure.
*
******************************************************************************/
int XCanPs_SelfTest(XCanPs *InstancePtr)
{
u8 *FramePtr;
u32 Status;
u32 Index;
Xil_AssertNonvoid(InstancePtr != NULL);
Xil_AssertNonvoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY);
XCanPs_Reset(InstancePtr);
/*
* The device should enter Configuration Mode immediately after
* reset above is finished. Now check the mode and return error code if
* it is not Configuration Mode.
*/
if (XCanPs_GetMode(InstancePtr) != XCANPS_MODE_CONFIG) {
return XST_FAILURE;
}
/*
* Setup Baud Rate Prescaler Register (BRPR) and Bit Timing Register
* (BTR) such that CAN baud rate equals 40Kbps, given the CAN clock
* equal to 24MHz. For more information see the CAN 2.0A, CAN 2.0B,
* ISO 11898-1 specifications.
*/
XCanPs_SetBaudRatePrescaler(InstancePtr, 1);
XCanPs_SetBitTiming(InstancePtr, 1, 3, 8);
/*
* Enter the loop back mode.
*/
XCanPs_EnterMode(InstancePtr, XCANPS_MODE_LOOPBACK);
while (XCanPs_GetMode(InstancePtr) != XCANPS_MODE_LOOPBACK);
/*
* Create a frame to send with known values so we can verify them
* on receive.
*/
TxFrame[0] = (u32)XCanPs_CreateIdValue((u32)2000, 0, 0, 0, 0);
TxFrame[1] = (u32)XCanPs_CreateDlcValue((u32)8);
FramePtr = (u8 *) (&TxFrame[2]);
for (Index = 0; Index < 8; Index++) {
*FramePtr++ = (u8) Index;
}
/*
* Send the frame.
*/
Status = XCanPs_Send(InstancePtr, TxFrame);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Wait until the frame arrives RX FIFO via internal loop back.
*/
while (XCanPs_IsRxEmpty(InstancePtr) == TRUE);
/*
* Receive the frame.
*/
Status = XCanPs_Recv(InstancePtr, RxFrame);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Verify Identifier and Data Length Code.
*/
if (RxFrame[0] !=
(u32)XCanPs_CreateIdValue((u32)2000, 0, 0, 0, 0)) {
return XST_FAILURE;
}
if ((RxFrame[1] & ~XCANPS_DLCR_TIMESTAMP_MASK) != TxFrame[1]) {
return XST_FAILURE;
}
for (Index = 2; Index < XCANPS_MAX_FRAME_SIZE_IN_WORDS; Index++) {
if (RxFrame[Index] != TxFrame[Index]) {
return XST_FAILURE;
}
}
/*
* Reset device again before returning to the caller.
*/
XCanPs_Reset(InstancePtr);
return XST_SUCCESS;
}
/**
*
* Read the Received CAN frames from the FIFO.
*
* @param InstancePtr is a pointer to the driver instance.
*
* @return
* - XST_SUCCESS if all the CAN Frames are received and the
* data is the same as that was sent.
* - XST_FAILURE if the required number of CAN frames have not
* been received or if the Received Data is not the same as the
* data that was sent.
*
* @note None.
*
******************************************************************************/
static int ReceiveData(XCanPs *InstancePtr)
{
int Status;
int Index;
u8 *FramePtr;
u8 NumRxFrames;
/*
* Initialize the number of received frames to Zero.
*/
NumRxFrames = 0;
/*
* Read the received CAN Frames from the FIFO till the FIFO is Empty.
*/
while (XCanPs_IntrGetStatus(InstancePtr) & XCANPS_IXR_RXNEMP_MASK) {
Status = XCanPs_Recv(InstancePtr, RxFrame);
if (Status != XST_SUCCESS) {
LoopbackError = TRUE;
return XST_FAILURE;
}
/*
* Verify Identifier and Data Length Code.
*/
if (RxFrame[0] !=
(u32)XCanPs_CreateIdValue((u32)TEST_MESSAGE_ID, 0, 0, 0, 0)) {
LoopbackError = TRUE;
return XST_FAILURE;
}
if ((RxFrame[1] & ~XCANPS_DLCR_TIMESTAMP_MASK) != TxFrame[1]) {
LoopbackError = TRUE;
return XST_FAILURE;
}
/*
* Verify Data field contents.
*/
FramePtr = (u8 *)(&RxFrame[2]);
for (Index = 0; Index < FRAME_DATA_LENGTH; Index++) {
if (*FramePtr++ != ((u8)Index + TestDataOffset)) {
LoopbackError = TRUE;
return XST_FAILURE;
}
}
/*
* Increment the number of frames received.
*/
TestDataOffset++;
NumRxFrames++;
}
if (NumRxFrames == TEST_THRESHOLD) {
LoopbackError = FALSE;
return XST_SUCCESS;
}
return XST_FAILURE;
}
