/** * * Callback function (called from interrupt handler) to handle the following * interrupts: * - XCANPS_IXR_BSOFF_MASK: Bus Off Interrupt * - XCANPS_IXR_RXOFLW_MASK: RX FIFO Overflow Interrupt * - XCANPS_IXR_RXUFLW_MASK: RX FIFO Underflow Interrupt * - XCANPS_IXR_TXBFLL_MASK: TX High Priority Buffer Full Interrupt * - XCANPS_IXR_TXFLL_MASK: TX FIFO Full Interrupt * - XCANPS_IXR_WKUP_MASK: Wake up Interrupt * - XCANPS_IXR_SLP_MASK: Sleep Interrupt * - XCANPS_IXR_ARBLST_MASK: Arbitration Lost Interrupt * * * @param CallBackRef is the callback reference passed from the * interrupt Handler, which in our case is a pointer to the * driver instance. * @param IntrMask is a bit mask indicating pending interrupts. * Its value equals 'OR'ing one or more of the XCANPS_IXR_*_MASK * value(s) mentioned above. * * @return None. * * @note This function is called by the driver within interrupt context. * This function should be changed to meet specific application * needs. * ******************************************************************************/ static void EventHandler(void *CallBackRef, u32 IntrMask) { XCanPs *CanPtr = (XCanPs *)CallBackRef; if (IntrMask & XCANPS_IXR_BSOFF_MASK) { /* * Entering Bus off status interrupt requires * the CAN device be reset and reconfigured. */ XCanPs_Reset(CanPtr); Config(CanPtr); return; } if(IntrMask & XCANPS_IXR_RXOFLW_MASK) { /* * Code to handle RX FIFO Overflow Interrupt should be put here. */ } if(IntrMask & XCANPS_IXR_RXUFLW_MASK) { /* * Code to handle RX FIFO Underflow Interrupt * should be put here. */ } if(IntrMask & XCANPS_IXR_TXBFLL_MASK) { /* * Code to handle TX High Priority Buffer Full * Interrupt should be put here. */ } if(IntrMask & XCANPS_IXR_TXFLL_MASK) { /* * Code to handle TX FIFO Full Interrupt should be put here. */ } if (IntrMask & XCANPS_IXR_WKUP_MASK) { /* * Code to handle Wake up from sleep mode Interrupt * should be put here. */ } if (IntrMask & XCANPS_IXR_SLP_MASK) { /* * Code to handle Enter sleep mode Interrupt should be put here. */ } if (IntrMask & XCANPS_IXR_ARBLST_MASK) { /* * Code to handle Lost bus arbitration Interrupt * should be put here. */ } }
/** * * 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; }