/**
*
* This function configures CAN device. Baud Rate Prescaler Register (BRPR) and
* Bit Timing Register (BTR) are set in this function.
*
* @param InstancePtr is a pointer to the driver instance.
*
* @return None.
*
* @note If the CAN device is not working correctly, this function may
* enter an infinite loop and will never return to the caller.
*
******************************************************************************/
static void Config(XCanPs *InstancePtr)
{
/*
* Enter Configuration Mode if the device is not currently in
* Configuration Mode.
*/
XCanPs_EnterMode(InstancePtr, XCANPS_MODE_CONFIG);
while(XCanPs_GetMode(InstancePtr) != XCANPS_MODE_CONFIG);
/*
* Setup Baud Rate Prescaler Register (BRPR) and
* Bit Timing Register (BTR).
*/
XCanPs_SetBaudRatePrescaler(InstancePtr, TEST_BRPR_BAUD_PRESCALAR);
XCanPs_SetBitTiming(InstancePtr, TEST_BTR_SYNCJUMPWIDTH,
TEST_BTR_SECOND_TIMESEGMENT,
TEST_BTR_FIRST_TIMESEGMENT);
}
/**
*
* 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;
}
/**
*
* The main entry point for showing the XCanPs driver in interrupt mode.
* The example configures the device for internal loop back mode, then
* sends a CAN frame and receives the same CAN frame.
*
* @param IntcInstPtr is a pointer to the instance of the INTC driver.
* @param CanInstPtr is a pointer to the instance of the CAN driver which
* is going to be connected to the interrupt controller.
* @param CanDeviceId is the device Id of the CAN device and is typically
* XPAR_<CANPS_instance>_DEVICE_ID value from xparameters.h.
* @param CanIntrId is the interrupt Id and is typically
* XPAR_<CANPS_instance>_INTR value from xparameters.h.
*
* @return XST_SUCCESS if successful, otherwise driver-specific error code.
*
* @note If the device is not working correctly, this function may enter
* an infinite loop and will never return to the caller.
*
******************************************************************************/
int CanPsIntrExample(INTC *IntcInstPtr, XCanPs *CanInstPtr,
u16 CanDeviceId, u16 CanIntrId)
{
int Status;
XCanPs_Config *ConfigPtr;
/*
* Initialize the Can device.
*/
ConfigPtr = XCanPs_LookupConfig(CanDeviceId);
if (ConfigPtr == NULL) {
return XST_FAILURE;
}
XCanPs_CfgInitialize(CanInstPtr,
ConfigPtr,
ConfigPtr->BaseAddr);
/*
* Run self-test on the device, which verifies basic sanity of the
* device and the driver.
*/
Status = XCanPs_SelfTest(CanInstPtr);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Configure CAN device.
*/
Config(CanInstPtr);
/*
* Set interrupt handlers.
*/
XCanPs_SetHandler(CanInstPtr, XCANPS_HANDLER_SEND,
(void *)SendHandler, (void *)CanInstPtr);
XCanPs_SetHandler(CanInstPtr, XCANPS_HANDLER_RECV,
(void *)RecvHandler, (void *)CanInstPtr);
XCanPs_SetHandler(CanInstPtr, XCANPS_HANDLER_ERROR,
(void *)ErrorHandler, (void *)CanInstPtr);
XCanPs_SetHandler(CanInstPtr, XCANPS_HANDLER_EVENT,
(void *)EventHandler, (void *)CanInstPtr);
/*
* Initialize the flags.
*/
SendDone = FALSE;
RecvDone = FALSE;
LoopbackError = FALSE;
/*
* Connect to the interrupt controller.
*/
Status = SetupInterruptSystem(IntcInstPtr,
CanInstPtr,
CanIntrId);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Enable all interrupts in CAN device.
*/
XCanPs_IntrEnable(CanInstPtr, XCANPS_IXR_ALL);
/*
* Enter Loop Back Mode.
*/
XCanPs_EnterMode(CanInstPtr, XCANPS_MODE_LOOPBACK);
while(XCanPs_GetMode(CanInstPtr) != XCANPS_MODE_LOOPBACK);
/*
* Loop back a frame. The RecvHandler is expected to handle
* the frame reception.
*/
SendFrame(CanInstPtr); /* Send a frame */
/*
* Wait here until both sending and reception have been completed.
*/
while ((SendDone != TRUE) || (RecvDone != TRUE));
/*
* Check for errors found in the callbacks.
*/
if (LoopbackError == TRUE) {
return XST_LOOPBACK_ERROR;
}
return XST_SUCCESS;
}
/**
*
* The entry point for showing the XCanPs driver in polled mode. The example
* configures the device for internal loop back mode, then sends a Can
* frame, receives the same Can frame, and verifies the frame contents.
*
* @param DeviceId is the XPAR_<CANPS_instance>_DEVICE_ID value from
* xparameters.h
*
* @return XST_SUCCESS if successful, otherwise driver-specific error code.
*
* @note
*
* If the device is not working correctly, this function may enter an infinite
* loop and will never return to the caller.
*
******************************************************************************/
int CanPsPolledExample(u16 DeviceId)
{
int Status;
XCanPs *CanInstPtr = &Can;
XCanPs_Config *ConfigPtr;
/*
* Initialize the Can device.
*/
ConfigPtr = XCanPs_LookupConfig(DeviceId);
if (CanInstPtr == NULL) {
return XST_FAILURE;
}
Status = XCanPs_CfgInitialize(CanInstPtr,
ConfigPtr,
ConfigPtr->BaseAddr);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Run self-test on the device, which verifies basic sanity of the
* device and the driver.
*/
Status = XCanPs_SelfTest(CanInstPtr);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Enter Configuration Mode so we can setup Baud Rate Prescaler
* Register (BRPR) and Bit Timing Register (BTR).
*/
XCanPs_EnterMode(CanInstPtr, XCANPS_MODE_CONFIG);
while(XCanPs_GetMode(CanInstPtr) != XCANPS_MODE_CONFIG);
/*
* Setup Baud Rate Prescaler Register (BRPR) and
* Bit Timing Register (BTR).
*/
XCanPs_SetBaudRatePrescaler(CanInstPtr, TEST_BRPR_BAUD_PRESCALAR);
XCanPs_SetBitTiming(CanInstPtr, TEST_BTR_SYNCJUMPWIDTH,
TEST_BTR_SECOND_TIMESEGMENT,
TEST_BTR_FIRST_TIMESEGMENT);
/*
* Enter Loop Back Mode.
*/
XCanPs_EnterMode(CanInstPtr, XCANPS_MODE_LOOPBACK);
while(XCanPs_GetMode(CanInstPtr) != XCANPS_MODE_LOOPBACK);
/*
* Send a frame, receive the frame via the loop back and verify its
* contents.
*/
Status = SendFrame(CanInstPtr);
if (Status != XST_SUCCESS) {
return Status;
}
Status = RecvFrame(CanInstPtr);
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;
}
/**
*
* The main entry point for showing the usage of XCanPs driver in interrupt
* mode. The example configures the device for internal loop back mode, then
* sends multiple CAN frames and receives the same number of CAN frame's
* using the Rx Watermark Interrupt.
*
* @param IntcInstPtr is a pointer to the instance of the ScuGic driver.
* @param CanInstPtr is a pointer to the instance of the CAN driver which
* is going to be connected to the interrupt controller.
* @param CanDeviceId is the device Id of the CAN device and is typically
* XPAR_<CANPS_instance>_DEVICE_ID value from xparameters.h.
* @param CanIntrId is the interrupt Id and is typically
* XPAR_<CANPS_instance>_INTR value from xparameters.h.
*
* @return XST_SUCCESS if successful, otherwise driver-specific error code.
*
* @note If the device is not working correctly, this function may enter
* an infinite loop and will never return to the caller.
*
******************************************************************************/
int CanPsWatermarkIntrExample(XScuGic *IntcInstPtr, XCanPs *CanInstPtr,
u16 CanDeviceId, u16 CanIntrId)
{
int Status;
XCanPs_Config *ConfigPtr;
u32 Index;
/*
* Initialize the Can device.
*/
ConfigPtr = XCanPs_LookupConfig(CanDeviceId);
if (ConfigPtr == NULL) {
return XST_FAILURE;
}
Status = XCanPs_CfgInitialize(CanInstPtr,
ConfigPtr,
ConfigPtr->BaseAddr);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Run self-test on the device, which verifies basic sanity of the
* device and the driver.
*/
Status = XCanPs_SelfTest(CanInstPtr);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Configure the CAN device.
*/
Config(CanInstPtr);
/*
* Set the interrupt handlers.
*/
XCanPs_SetHandler(CanInstPtr, XCANPS_HANDLER_SEND,
(void *)SendHandler, (void *)CanInstPtr);
XCanPs_SetHandler(CanInstPtr, XCANPS_HANDLER_RECV,
(void *)RecvHandler, (void *)CanInstPtr);
XCanPs_SetHandler(CanInstPtr, XCANPS_HANDLER_ERROR,
(void *)ErrorHandler, (void *)CanInstPtr);
XCanPs_SetHandler(CanInstPtr, XCANPS_HANDLER_EVENT,
(void *)EventHandler, (void *)CanInstPtr);
/*
* Initialize flags.
*/
SendDone = FALSE;
RecvDone = FALSE;
LoopbackError = FALSE;
/*
* Connect to the interrupt controller.
*/
Status = SetupInterruptSystem(IntcInstPtr,
CanInstPtr,
CanIntrId);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Enable all interrupts in CAN device.
*/
XCanPs_IntrEnable(CanInstPtr, XCANPS_IXR_ALL);
/*
* Disable the Receive FIFO Not Empty Interrupt and the
* New Message Received Interrupt.
*/
XCanPs_IntrDisable(CanInstPtr,
XCANPS_IXR_RXNEMP_MASK |
XCANPS_IXR_RXOK_MASK);
/*
* Enter Loop Back Mode.
*/
XCanPs_EnterMode(CanInstPtr, XCANPS_MODE_LOOPBACK);
while(XCanPs_GetMode(CanInstPtr) != XCANPS_MODE_LOOPBACK);
/*
* Send a number of frames.
*/
TestDataOffset = 1;
for (Index = 0; Index < TEST_THRESHOLD; Index++) {
SendFrame(CanInstPtr); /* Send a frame */
TestDataOffset++;
}
/*
* Wait here until both sending and reception have been completed.
*/
while ((SendDone < TEST_THRESHOLD) || (RecvDone != TRUE));
/*
* Check for errors found in the callbacks.
*/
if (LoopbackError == TRUE) {
return XST_FAILURE;
}
/*
* Read the Received Frames from the FIFO.
*/
TestDataOffset = 1;
Status = ReceiveData(CanInstPtr);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Check for errors found in the callbacks.
*/
if (LoopbackError == TRUE) {
return XST_LOOPBACK_ERROR;
}
return XST_SUCCESS;
}