/** * * 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; }
/** * * 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; }