73 #if (defined(CAN_OVER_FLEXCAN))
80 } flexcan_rx_fifo_state_t;
87 #if (defined(CAN_OVER_FLEXCAN))
92 static uint32_t s_flexcanStateInstanceMapping[NO_OF_FLEXCAN_INSTS_FOR_CAN];
94 static bool s_flexcanStateIsAllocated[NO_OF_FLEXCAN_INSTS_FOR_CAN];
98 static flexcan_rx_fifo_state_t s_flexcanRxFifoState[NO_OF_FLEXCAN_INSTS_FOR_CAN];
115 uint32_t *instanceMapping,
117 uint8_t numberOfinstances)
121 for (i = 0; i < numberOfinstances; i++)
123 if (isAllocated[i] ==
false)
125 instanceMapping[i] = instance;
126 isAllocated[i] =
true;
140 const uint32_t *instanceMapping,
142 uint8_t numberOfinstances)
146 for (i = 0; i < numberOfinstances; i++)
148 if (instanceMapping[i] == instance)
150 isAllocated[i] =
false;
156 #if (defined(CAN_OVER_FLEXCAN))
164 static uint8_t CAN_FindFlexCANState(uint32_t instance)
168 for (i = 0; i < NO_OF_FLEXCAN_INSTS_FOR_CAN; i++)
170 if (s_flexcanStateInstanceMapping[i] == instance)
185 static inline uint32_t CAN_GetVirtualBuffIdx(uint32_t x)
187 return (5U + ((((x) + 1U) * 8U) / 4U));
197 static void CAN_InternalCallback(uint8_t instance,
202 uint8_t index = CAN_FindFlexCANState(instance);
206 if ((s_flexcanRxFifoState[index].rxFifoEn ==
true) && (buffIdx != 0U))
208 buffIdx -= CAN_GetVirtualBuffIdx((uint32_t) s_flexcanRxFifoState[index].numIdFilters);
261 #if (defined (CAN_OVER_FLEXCAN))
270 s_flexcanStateInstanceMapping,
272 NO_OF_FLEXCAN_INSTS_FOR_CAN);
275 s_flexcanRxFifoState[index].rxFifoEn =
false;
291 #if FEATURE_CAN_HAS_FD
299 #if FEATURE_CAN_HAS_PE_CLKSRC_SELECT
309 #if FEATURE_CAN_HAS_DMA_ENABLE
318 s_flexcanRxFifoState[index].rxFifoEn =
true;
319 s_flexcanRxFifoState[index].numIdFilters = flexcanConfig.
num_id_filters;
325 #if FEATURE_CAN_HAS_DMA_ENABLE
333 &s_flexcanState[index],
338 (s_flexcanRxFifoState[index].rxFifoEn ==
true))
342 ((extension_flexcan_rx_fifo_t *) (config->
extension))->idFormat,
343 ((extension_flexcan_rx_fifo_t *) (config->
extension))->idFilterTable);
365 #if defined(CAN_OVER_FLEXCAN)
375 s_flexcanStateInstanceMapping,
377 NO_OF_FLEXCAN_INSTS_FOR_CAN);
402 #if defined(CAN_OVER_FLEXCAN)
412 #if FEATURE_CAN_HAS_FD
442 #if defined(CAN_OVER_FLEXCAN)
452 #if FEATURE_CAN_HAS_FD
483 #if defined(CAN_OVER_FLEXCAN)
488 index = CAN_FindFlexCANState(instance->
instIdx);
491 DEV_ASSERT((s_flexcanRxFifoState[index].rxFifoEn ==
false) || (buffIdx != 0U));
497 .data_length = (config->
enableFD ? (uint32_t) 64U : (uint32_t) 8U),
507 s_hwObjConfigs[index][buffIdx] = config;
510 if (s_flexcanRxFifoState[index].rxFifoEn)
512 buffIdx += CAN_GetVirtualBuffIdx(s_flexcanRxFifoState[index].numIdFilters);
547 #if defined(CAN_OVER_FLEXCAN)
552 index = CAN_FindFlexCANState(instance->
instIdx);
555 DEV_ASSERT((s_flexcanRxFifoState[index].rxFifoEn ==
false) || (buffIdx != 0U));
561 .data_length = message->
length,
562 #if FEATURE_CAN_HAS_FD
571 s_hwObjConfigs[index][buffIdx] = config;
574 if (s_flexcanRxFifoState[index].rxFifoEn)
576 buffIdx += CAN_GetVirtualBuffIdx(s_flexcanRxFifoState[index].numIdFilters);
610 #if defined(CAN_OVER_FLEXCAN)
615 index = CAN_FindFlexCANState(instance->
instIdx);
618 DEV_ASSERT((s_flexcanRxFifoState[index].rxFifoEn ==
false) || (buffIdx != 0U));
624 .data_length = (config->
enableFD ? (uint32_t) 64U : (uint32_t) 8U),
634 s_hwObjConfigs[index][buffIdx] = config;
637 if (s_flexcanRxFifoState[index].rxFifoEn)
639 buffIdx += CAN_GetVirtualBuffIdx(s_flexcanRxFifoState[index].numIdFilters);
671 #if defined(CAN_OVER_FLEXCAN)
676 index = CAN_FindFlexCANState(instance->
instIdx);
679 DEV_ASSERT((s_flexcanRxFifoState[index].rxFifoEn ==
false) || (buffIdx != 0U));
685 .data_length = message->
length,
687 .fd_enable = s_hwObjConfigs[index][buffIdx]->
enableFD,
688 .fd_padding = s_hwObjConfigs[index][buffIdx]->
fdPadding,
689 .enable_brs = s_hwObjConfigs[index][buffIdx]->
enableBRS,
691 .is_remote = s_hwObjConfigs[index][buffIdx]->
isRemote
695 if (s_flexcanRxFifoState[index].rxFifoEn)
697 buffIdx += CAN_GetVirtualBuffIdx(s_flexcanRxFifoState[index].numIdFilters);
731 #if defined(CAN_OVER_FLEXCAN)
736 index = CAN_FindFlexCANState(instance->
instIdx);
739 DEV_ASSERT((s_flexcanRxFifoState[index].rxFifoEn ==
false) || (buffIdx != 0U));
745 .data_length = message->
length,
747 .fd_enable = s_hwObjConfigs[index][buffIdx]->
enableFD,
748 .fd_padding = s_hwObjConfigs[index][buffIdx]->
fdPadding,
749 .enable_brs = s_hwObjConfigs[index][buffIdx]->
enableBRS,
751 .is_remote = s_hwObjConfigs[index][buffIdx]->
isRemote
755 if (s_flexcanRxFifoState[index].rxFifoEn)
757 buffIdx += CAN_GetVirtualBuffIdx(s_flexcanRxFifoState[index].numIdFilters);
790 #if defined(CAN_OVER_FLEXCAN)
797 index = CAN_FindFlexCANState(instance->
instIdx);
800 if ((s_flexcanRxFifoState[index].rxFifoEn ==
true) && (buffIdx == 0U))
808 if (s_flexcanRxFifoState[index].rxFifoEn)
810 buffIdx += CAN_GetVirtualBuffIdx(s_flexcanRxFifoState[index].numIdFilters);
843 #if defined(CAN_OVER_FLEXCAN)
850 index = CAN_FindFlexCANState(instance->
instIdx);
853 if ((s_flexcanRxFifoState[index].rxFifoEn ==
true) && (buffIdx == 0U))
862 if (s_flexcanRxFifoState[index].rxFifoEn)
864 buffIdx += CAN_GetVirtualBuffIdx(s_flexcanRxFifoState[index].numIdFilters);
894 #if defined(CAN_OVER_FLEXCAN)
901 index = CAN_FindFlexCANState(instance->
instIdx);
904 if (s_flexcanRxFifoState[index].rxFifoEn)
906 buffIdx += CAN_GetVirtualBuffIdx(s_flexcanRxFifoState[index].numIdFilters);
935 #if defined(CAN_OVER_FLEXCAN)
940 index = CAN_FindFlexCANState(instance->
instIdx);
943 DEV_ASSERT((s_flexcanRxFifoState[index].rxFifoEn ==
false) || (buffIdx != 0U));
976 #if defined(CAN_OVER_FLEXCAN)
983 index = CAN_FindFlexCANState(instance->
instIdx);
986 if ((s_flexcanRxFifoState[index].rxFifoEn) && (buffIdx != 0U))
988 buffIdx += CAN_GetVirtualBuffIdx(s_flexcanRxFifoState[index].numIdFilters);
1008 void *callbackParam)
1016 #if defined(CAN_OVER_FLEXCAN)
1019 if (callback != NULL)
1023 index = CAN_FindFlexCANState(instance->
instIdx);
1026 userCallbacks[index] = callback;
1029 CAN_InternalCallback,
#define FEATURE_CAN_HAS_FD
status_t CAN_Receive(const can_instance_t *const instance, uint32_t buffIdx, can_message_t *message)
Receives a CAN frame using the specified message buffer.
status_t CAN_AbortTransfer(const can_instance_t *const instance, uint32_t buffIdx)
Ends a non-blocking CAN transfer early.
status_t FLEXCAN_DRV_Receive(uint8_t instance, uint8_t mb_idx, flexcan_msgbuff_t *data)
Receives a CAN frame using the specified message buffer.
void FLEXCAN_DRV_GetBitrateFD(uint8_t instance, flexcan_time_segment_t *bitrate)
Gets the FlexCAN bit rate for the data phase of FD frames (BRS enabled).
status_t FLEXCAN_DRV_Deinit(uint8_t instance)
Shuts down a FlexCAN instance.
Internal driver state information.
flexcan_msgbuff_id_type_t
FlexCAN Message Buffer ID type Implements : flexcan_msgbuff_id_type_t_Class.
flexcan_operation_modes_t flexcanMode
can_time_segment_t dataBitrate
flexcan_fd_payload_size_t payload
status_t FLEXCAN_DRV_ConfigTxMb(uint8_t instance, uint8_t mb_idx, const flexcan_data_info_t *tx_info, uint32_t msg_id)
FlexCAN transmit message buffer field configuration.
flexcan_time_segment_t bitrate
status_t CAN_GetTransferStatus(const can_instance_t *const instance, uint32_t buffIdx)
Returns the state of the previous CAN transfer.
flexcan_rx_fifo_id_filter_num_t num_id_filters
flexcan_clk_source_t
FlexCAN PE clock sources Implements : flexcan_clk_source_t_Class.
status_t FLEXCAN_DRV_RxFifo(uint8_t instance, flexcan_msgbuff_t *data)
Receives a CAN frame using the message FIFO.
flexcan_rx_fifo_id_filter_num_t
FlexCAN Rx FIFO filters number Implements : flexcan_rx_fifo_id_filter_num_t_Class.
status_t CAN_ConfigRxBuff(const can_instance_t *const instance, uint32_t buffIdx, const can_buff_config_t *config, uint32_t acceptedId)
Configures a buffer for reception.
can_msg_id_type_t
CAN Message Buffer ID type Implements : can_msg_id_type_t_Class.
void FLEXCAN_DRV_ConfigRxFifo(uint8_t instance, flexcan_rx_fifo_id_element_format_t id_format, const flexcan_id_table_t *id_filter_table)
FlexCAN Rx FIFO field configuration.
status_t FLEXCAN_DRV_GetTransferStatus(uint8_t instance, uint8_t mb_idx)
Returns whether the previous FlexCAN transfer has finished.
flexcan_msgbuff_id_type_t msg_id_type
flexcan_event_type_t
The type of the event which occurred when the callback was invoked. Implements : flexcan_event_type_t...
can_operation_modes_t mode
void FLEXCAN_DRV_InstallEventCallback(uint8_t instance, flexcan_callback_t callback, void *callbackParam)
Installs a callback function for the IRQ handler.
#define CAN_INSTANCE_COUNT
status_t CAN_InstallEventCallback(const can_instance_t *const instance, can_callback_t callback, void *callbackParam)
Installs a callback function for the IRQ handler.
#define FEATURE_CAN_MAX_MB_NUM
status_t FLEXCAN_DRV_AbortTransfer(uint8_t instance, uint8_t mb_idx)
Ends a non-blocking FlexCAN transfer early.
void FLEXCAN_DRV_SetRxMaskType(uint8_t instance, flexcan_rx_mask_type_t type)
Sets the Rx masking type.
status_t CAN_ConfigTxBuff(const can_instance_t *const instance, uint32_t buffIdx, const can_buff_config_t *config)
Configures a buffer for transmission.
FlexCAN bitrate related structures Implements : flexcan_time_segment_t_Class.
status_t FLEXCAN_DRV_ConfigRxMb(uint8_t instance, uint8_t mb_idx, const flexcan_data_info_t *rx_info, uint32_t msg_id)
FlexCAN receive message buffer field configuration.
status_t CAN_Deinit(const can_instance_t *const instance)
De-initializes the CAN module.
status_t CAN_SendBlocking(const can_instance_t *const instance, uint32_t buffIdx, const can_message_t *message, uint32_t timeoutMs)
Sends a CAN frame using the specified buffer, in a blocking manner.
status_t FLEXCAN_DRV_ConfigRemoteResponseMb(uint8_t instance, uint8_t mb_idx, const flexcan_data_info_t *tx_info, uint32_t msg_id, const uint8_t *mb_data)
Configures a transmit message buffer for remote frame response.
void(* can_callback_t)(uint32_t instance, can_event_t eventType, uint32_t objIdx, void *driverState)
status_t
Status return codes. Common error codes will be a unified enumeration (C enum) that will contain all ...
Structure storing PAL instance information.
CAN buffer configuration Implements : can_buff_config_t_Class.
status_t CAN_GetBitrate(const can_instance_t *const instance, can_bitrate_phase_t phase, can_time_segment_t *bitTiming)
Returns the CAN bitrate.
static uint8_t CAN_AllocateState(bool *isAllocated, uint32_t *instanceMapping, uint32_t instance, uint8_t numberOfinstances)
FlexCAN message buffer structure Implements : flexcan_msgbuff_t_Class.
status_t CAN_SetBitrate(const can_instance_t *const instance, can_bitrate_phase_t phase, const can_time_segment_t *bitTiming)
Configures the CAN bitrate.
can_clk_source_t peClkSrc
status_t FLEXCAN_DRV_SendBlocking(uint8_t instance, uint8_t mb_idx, const flexcan_data_info_t *tx_info, uint32_t msg_id, const uint8_t *mb_data, uint32_t timeout_ms)
Sends a CAN frame using the specified message buffer, in a blocking manner.
CAN controller configuration Implements : can_user_config_t_Class.
status_t CAN_Send(const can_instance_t *const instance, uint32_t buffIdx, const can_message_t *message)
Sends a CAN frame using the specified buffer.
status_t FLEXCAN_DRV_RxFifoBlocking(uint8_t instance, flexcan_msgbuff_t *data, uint32_t timeout_ms)
Receives a CAN frame using the message FIFO, in a blocking manner.
CAN message format Implements : can_message_t_Class.
CAN bit timing variables Implements : can_time_segment_t_Class.
flexcan_time_segment_t bitrate_cbt
flexcan_rxfifo_transfer_type_t transfer_type
can_fd_payload_size_t payloadSize
can_bitrate_phase_t
CAN bitrate phase (nominal/data) Implements : can_bitrate_phase_t_Class.
can_time_segment_t nominalBitrate
status_t FLEXCAN_DRV_ReceiveBlocking(uint8_t instance, uint8_t mb_idx, flexcan_msgbuff_t *data, uint32_t timeout_ms)
Receives a CAN frame using the specified message buffer, in a blocking manner.
void FLEXCAN_DRV_SetBitrateCbt(uint8_t instance, const flexcan_time_segment_t *bitrate)
Sets the FlexCAN bit rate for the data phase of FD frames (BRS enabled).
status_t CAN_SetRxFilter(const can_instance_t *const instance, can_msg_id_type_t idType, uint32_t buffIdx, uint32_t mask)
Configures an ID filter for a specific reception buffer.
FlexCAN data info from user Implements : flexcan_data_info_t_Class.
status_t FLEXCAN_DRV_Init(uint8_t instance, flexcan_state_t *state, const flexcan_user_config_t *data)
Initializes the FlexCAN peripheral.
flexcan_fd_payload_size_t
FlexCAN payload sizes Implements : flexcan_fd_payload_size_t_Class.
status_t FLEXCAN_DRV_Send(uint8_t instance, uint8_t mb_idx, const flexcan_data_info_t *tx_info, uint32_t msg_id, const uint8_t *mb_data)
Sends a CAN frame using the specified message buffer.
status_t FLEXCAN_DRV_SetRxIndividualMask(uint8_t instance, flexcan_msgbuff_id_type_t id_type, uint8_t mb_idx, uint32_t mask)
Sets the FlexCAN Rx individual mask (standard or extended).
status_t CAN_ConfigRemoteResponseBuff(const can_instance_t *const instance, uint32_t buffIdx, const can_buff_config_t *config, const can_message_t *message)
Configures a transmit buffer for remote frame response.
status_t CAN_ReceiveBlocking(const can_instance_t *const instance, uint32_t buffIdx, can_message_t *message, uint32_t timeoutMs)
Receives a CAN frame using the specified buffer, in a blocking manner.
void FLEXCAN_DRV_SetBitrate(uint8_t instance, const flexcan_time_segment_t *bitrate)
Sets the FlexCAN bit rate for standard frames or the arbitration phase of FD frames.
flexcan_clk_source_t pe_clock
status_t CAN_Init(const can_instance_t *const instance, const can_user_config_t *config)
Initializes the CAN module.
flexcan_operation_modes_t
FlexCAN operation modes Implements : flexcan_operation_modes_t_Class.
void FLEXCAN_DRV_GetBitrate(uint8_t instance, flexcan_time_segment_t *bitrate)
Gets the FlexCAN bit rate for standard frames or the arbitration phase of FD frames.
static void CAN_FreeState(bool *isAllocated, const uint32_t *instanceMapping, uint32_t instance, uint8_t numberOfinstances)