diff options
Diffstat (limited to 'platform/drivers/inc/flexcan.h')
| -rw-r--r-- | platform/drivers/inc/flexcan.h | 661 |
1 files changed, 661 insertions, 0 deletions
diff --git a/platform/drivers/inc/flexcan.h b/platform/drivers/inc/flexcan.h new file mode 100644 index 0000000..8f27315 --- /dev/null +++ b/platform/drivers/inc/flexcan.h @@ -0,0 +1,661 @@ +/* + * Copyright (c) 2015, Freescale Semiconductor, Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * + * o Redistributions of source code must retain the above copyright notice, this list + * of conditions and the following disclaimer. + * + * o Redistributions in binary form must reproduce the above copyright notice, this + * list of conditions and the following disclaimer in the documentation and/or + * other materials provided with the distribution. + * + * o Neither the name of Freescale Semiconductor, Inc. nor the names of its + * contributors may be used to endorse or promote products derived from this + * software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON + * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef __FLEXCAN_H__ +#define __FLEXCAN_H__ + +#include <stdint.h> +#include <stdbool.h> +#include <assert.h> +#include "device_imx.h" + +/*! + * @addtogroup flexcan_driver + * @{ + */ + +/******************************************************************************* + * Definitions + ******************************************************************************/ + +/*! @brief FlexCAN message buffer CODE for Rx buffers */ +enum _flexcan_msgbuf_code_rx { + flexcanRxInactive = 0x0, /*!< MB is not active. */ + flexcanRxFull = 0x2, /*!< MB is full. */ + flexcanRxEmpty = 0x4, /*!< MB is active and empty. */ + flexcanRxOverrun = 0x6, /*!< MB is overwritten into a full buffer. */ + flexcanRxBusy = 0x8, /*!< FlexCAN is updating the contents of the MB. */ + /*! The CPU must not access the MB. */ + flexcanRxRanswer = 0xA, /*!< A frame was configured to recognize a Remote Request Frame */ + /*! and transmit a Response Frame in return. */ + flexcanRxNotUsed = 0xF /*!< Not used */ +}; + +/*! @brief FlexCAN message buffer CODE FOR Tx buffers */ +enum _flexcan_msgbuf_code_tx { + flexcanTxInactive = 0x8, /*!< MB is not active. */ + flexcanTxAbort = 0x9, /*!< MB is aborted. */ + flexcanTxDataOrRemte = 0xC, /*!< MB is a TX Data Frame(when MB RTR = 0) or */ + /*!< MB is a TX Remote Request Frame (when MB RTR = 1). */ + flexcanTxTanswer = 0xE, /*!< MB is a TX Response Request Frame from. */ + /*! an incoming Remote Request Frame. */ + flexcanTxNotUsed = 0xF /*!< Not used */ +}; + +/*! @brief FlexCAN operation modes */ +enum _flexcan_operatining_modes { + flexCanNormalMode = 0x1, /*!< Normal mode or user mode @internal gui name="Normal" */ + flexcanListenOnlyMode = 0x2, /*!< Listen-only mode @internal gui name="Listen-only" */ + flexcanLoopBackMode = 0x4, /*!< Loop-back mode @internal gui name="Loop back" */ +}; + +/*! @brief FlexCAN RX mask mode.*/ +enum _flexcan_rx_mask_mode { + flexcanRxMaskGlobal = 0x0, /*!< Rx global mask*/ + flexcanRxMaskIndividual = 0x1 /*!< Rx individual mask*/ +}; + +/*! @brief The ID type used in rx matching process. */ +enum _flexcan_rx_mask_id_type { + flexcanRxMaskIdStd = 0x0, /*!< Standard ID*/ + flexcanRxMaskIdExt = 0x1 /*!< Extended ID*/ +}; + +/*! @brief Flexcan error interrupt source enumeration. */ +enum _flexcan_interrutpt { + flexcanIntRxWarning = 0x01, + flexcanIntTxWarning = 0x02, + flexcanIntWakeUp = 0x04, + flexcanIntBusOff = 0x08, + flexcanIntError = 0x10, +}; + +/*! @brief Flexcan error interrupt flags. */ +enum _flexcan_status_flag { + flexcanStatusSynch = CAN_ESR1_SYNCH_MASK, + flexcanStatusTxWarningInt = CAN_ESR1_TWRN_INT_MASK, + flexcanStatusRxWarningInt = CAN_ESR1_RWRN_INT_MASK, + flexcanStatusBit1Err = CAN_ESR1_BIT1_ERR_MASK, + flexcanStatusBit0Err = CAN_ESR1_BIT0_ERR_MASK, + flexcanStatusAckErr = CAN_ESR1_ACK_ERR_MASK, + flexcanStatusCrcErr = CAN_ESR1_CRC_ERR_MASK, + flexcanStatusFrameErr = CAN_ESR1_FRM_ERR_MASK, + flexcanStatusStuffingErr = CAN_ESR1_FRM_ERR_MASK, + flexcanStatusTxWarning = CAN_ESR1_TX_WRN_MASK, + flexcanStatusRxWarning = CAN_ESR1_RX_WRN_MASK, + flexcanStatusIdle = CAN_ESR1_IDLE_MASK, + flexcanStatusTransmitting = CAN_ESR1_TX_MASK, + flexcanStatusFltConf = CAN_ESR1_FLT_CONF_MASK, + flexcanStatusReceiving = CAN_ESR1_RX_MASK, + flexcanStatusBusOff = CAN_ESR1_BOFF_INT_MASK, + flexcanStatusError = CAN_ESR1_ERR_INT_MASK, + flexcanStatusWake = CAN_ESR1_WAK_INT_MASK +}; + +/*! @brief The id filter element type selection. */ +enum _flexcan_rx_fifo_id_element_format { + flexcanFxFifoIdElementFormatA = 0x0, /*!< One full ID (standard and extended) per ID Filter Table*/ + /*! element.*/ + flexcanFxFifoIdElementFormatB = 0x1, /*!< Two full standard IDs or two partial 14-bit (standard and*/ + /*! extended) IDs per ID Filter Table element.*/ + flexcanFxFifoIdElementFormatC = 0x2, /*!< Four partial 8-bit Standard IDs per ID Filter Table*/ + /*! element.*/ + flexcanFxFifoIdElementFormatD = 0x3 /*!< All frames rejected.*/ +}; + +/*! @brief FlexCAN Rx FIFO filters number*/ +enum _flexcan_rx_fifo_filter_id_number +{ + flexcanRxFifoIdFilterNum8 = 0x0, /*!< 8 Rx FIFO Filters. @internal gui name="8 Rx FIFO Filters" */ + flexcanRxFifoIdFilterNum16 = 0x1, /*!< 16 Rx FIFO Filters. @internal gui name="16 Rx FIFO Filters" */ + flexcanRxFifoIdFilterNum24 = 0x2, /*!< 24 Rx FIFO Filters. @internal gui name="24 Rx FIFO Filters" */ + flexcanRxFifoIdFilterNum32 = 0x3, /*!< 32 Rx FIFO Filters. @internal gui name="32 Rx FIFO Filters" */ + flexcanRxFifoIdFilterNum40 = 0x4, /*!< 40 Rx FIFO Filters. @internal gui name="40 Rx FIFO Filters" */ + flexcanRxFifoIdFilterNum48 = 0x5, /*!< 48 Rx FIFO Filters. @internal gui name="48 Rx FIFO Filters" */ + flexcanRxFifoIdFilterNum56 = 0x6, /*!< 56 Rx FIFO Filters. @internal gui name="56 Rx FIFO Filters" */ + flexcanRxFifoIdFilterNum64 = 0x7, /*!< 64 Rx FIFO Filters. @internal gui name="64 Rx FIFO Filters" */ + flexcanRxFifoIdFilterNum72 = 0x8, /*!< 72 Rx FIFO Filters. @internal gui name="72 Rx FIFO Filters" */ + flexcanRxFifoIdFilterNum80 = 0x9, /*!< 80 Rx FIFO Filters. @internal gui name="80 Rx FIFO Filters" */ + flexcanRxFifoIdFilterNum88 = 0xA, /*!< 88 Rx FIFO Filters. @internal gui name="88 Rx FIFO Filters" */ + flexcanRxFifoIdFilterNum96 = 0xB, /*!< 96 Rx FIFO Filters. @internal gui name="96 Rx FIFO Filters" */ + flexcanRxFifoIdFilterNum104 = 0xC, /*!< 104 Rx FIFO Filters. @internal gui name="104 Rx FIFO Filters" */ + flexcanRxFifoIdFilterNum112 = 0xD, /*!< 112 Rx FIFO Filters. @internal gui name="112 Rx FIFO Filters" */ + flexcanRxFifoIdFilterNum120 = 0xE, /*!< 120 Rx FIFO Filters. @internal gui name="120 Rx FIFO Filters" */ + flexcanRxFifoIdFilterNum128 = 0xF, /*!< 128 Rx FIFO Filters. @internal gui name="128 Rx FIFO Filters" */ +}; + +/*! @brief FlexCAN RX FIFO ID filter table structure*/ +typedef struct FLEXCANIdTable { + bool isRemoteFrame; /*!< Remote frame*/ + bool isExtendedFrame; /*!< Extended frame*/ + uint32_t *idFilter; /*!< Rx FIFO ID filter elements*/ +} flexcan_id_table_t; + +/*! @brief FlexCAN message buffer structure*/ +typedef struct _flexcan_msgbuf { + union { + uint32_t cs; /*!< Code and Status*/ + struct { + uint32_t timeStamp : 16; + uint32_t dlc : 4; + uint32_t rtr : 1; + uint32_t ide : 1; + uint32_t srr : 1; + uint32_t reverse1 : 1; + uint32_t code : 4; + uint32_t reverse2 : 4; + }; + }; + + union{ + uint32_t id; /*!< Message Buffer ID*/ + struct { + uint32_t idExt : 18; + uint32_t idStd : 11; + uint32_t prio : 3; + }; + }; + + union{ + uint32_t word0; /*!< Bytes of the FlexCAN message*/ + struct { + uint8_t data3; + uint8_t data2; + uint8_t data1; + uint8_t data0; + }; + }; + + union{ + uint32_t word1; /*!< Bytes of the FlexCAN message*/ + struct { + uint8_t data7; + uint8_t data6; + uint8_t data5; + uint8_t data4; + }; + }; +} flexcan_msgbuf_t; + +/*! @brief FlexCAN timing related structures*/ +typedef struct _flexcan_timing { + uint32_t preDiv; /*!< Clock pre divider*/ + uint32_t rJumpwidth; /*!< Resync jump width*/ + uint32_t phaseSeg1; /*!< Phase segment 1*/ + uint32_t phaseSeg2; /*!< Phase segment 1*/ + uint32_t propSeg; /*!< Propagation segment*/ +} flexcan_timing_t; + +/*! @brief Flexcan module initialize structure. */ +typedef struct _flexcan_init_config { + flexcan_timing_t timing; /*!< Desired Flexcan module timing configuration. */ + uint32_t operatingMode; /*!< Desired Flexcan module operating mode. */ + uint8_t maxMsgBufNum; /*!< The maximal number of available message buffer. */ +} flexcan_init_config_t; + +/******************************************************************************* + * API + ******************************************************************************/ + +#if defined(__cplusplus) +extern "C" { +#endif + +/*! + * @name FlexCAN Initialization and Configuration functions + * @{ + */ + +/*! + * @brief Initialize Flexcan module with given initialize structure. + * + * @param base CAN base pointer. + * @param initConfig CAN initialize structure(see flexcan_init_config_t above). + */ +void FLEXCAN_Init(CAN_Type* base, flexcan_init_config_t* initConfig); + +/*! + * @brief This function reset Flexcan module register content to its default value. + * + * @param base FlexCAN base pointer. + */ +void FLEXCAN_Deinit(CAN_Type* base); + +/*! + * @brief This function is used to Enable the Flexcan Module. + * + * @param base FlexCAN base pointer. + */ +void FLEXCAN_Enable(CAN_Type* base); + +/*! + * @brief This function is used to Disable the CAN Module. + * + * @param base FlexCAN base pointer. + */ +void FLEXCAN_Disable(CAN_Type* base); + +/*! + * @brief Sets the FlexCAN time segments for setting up bit rate. + * + * @param base FlexCAN base pointer. + * @param timing FlexCAN time segments, which need to be set for the bit rate. + */ +void FLEXCAN_SetTiming(CAN_Type* base, flexcan_timing_t* timing); + +/*! + * @brief Set operation mode. + * + * @param base FlexCAN base pointer. + * @param mode Set an operation mode. + */ +void FLEXCAN_SetOperatingMode(CAN_Type* base, uint8_t mode); + +/*! + * @brief Set the maximum number of Message Buffers. + * + * @param base FlexCAN base pointer. + * @param bufNum Maximum number of message buffers + */ +void FLEXCAN_SetMaxMsgBufNum(CAN_Type* base, uint32_t bufNum); + +/*! + * @brief Get the working status of Flexcan module. + * + * @param base FlexCAN base pointer. + * @return true : FLEXCAN module is either in Normal Mode, Listen-Only Mode or Loop-Back Mode + * false : FLEXCAN module is either in Disable Mode, Stop Mode or Freeze Mode + */ +static inline bool FLEXCAN_IsModuleReady(CAN_Type* base) +{ + return !((CAN_MCR_REG(base) >> CAN_MCR_NOT_RDY_SHIFT) & 0x1); +} + +/*! + * @brief Set the Transmit abort feature enablement. + * + * @param base FlexCAN base pointer. + * @param enable - true : Enable Transmit Abort feature. + * - false : Disable Transmit Abort feature. + */ +void FLEXCAN_SetAbortCmd(CAN_Type* base, bool enable); + +/*! + * @brief Set the local transmit priority enablement. + * + * @param base FlexCAN base pointer. + * @param enable - true : transmit MB with highest local priority. + * - false : transmit MB with lowest MB number. + */ +void FLEXCAN_SetLocalPrioCmd(CAN_Type* base, bool enable); + +/*! + * @brief Set the Rx matching process priority. + * + * @param base FlexCAN base pointer. + * @param priority - true : Matching starts from Mailboxes and continues on Rx FIFO. + * - false : Matching starts from Rx FIFO and continues on Mailboxes. + */ +void FLEXCAN_SetMatchPrioCmd(CAN_Type* base, bool priority); + +/*@}*/ + +/*! + * @name Flexcan Message buffer control functions + * @{ + */ + +/*! + * @brief Get message buffer pointer for transition. + * + * @param base FlexCAN base pointer. + * @param msgBufIdx message buffer index. + * @return message buffer pointer. + */ +flexcan_msgbuf_t* FLEXCAN_GetMsgBufPtr(CAN_Type* base, uint8_t msgBufIdx); + +/*! + * @brief Locks the FlexCAN Rx message buffer. + * + * @param base FlexCAN base pointer. + * @param msgBuffIdx Index of the message buffer + * @return true : if successful; + * false : failed. + */ +bool FLEXCAN_LockRxMsgBuf(CAN_Type* base, uint8_t msgBufIdx); + +/*! + * @brief Unlocks the FlexCAN Rx message buffer. + * + * @param base FlexCAN base pointer. + * @return current free run timer counter value. + */ +uint16_t FLEXCAN_UnlockAllRxMsgBuf(CAN_Type* base); + +/*@}*/ + +/*! + * @name FlexCAN Interrupts and flags management functions + * @{ + */ + +/*! + * @brief Enables/Disables the FlexCAN Message Buffer interrupt. + * + * @param base FlexCAN base pointer. + * @param msgBuffIdx Index of the message buffer. + * @param enable Choose enable or disable. + */ +void FLEXCAN_SetMsgBufIntCmd(CAN_Type* base, uint8_t msgBufIdx, bool enable); + +/*! + * @brief Gets the individual FlexCAN MB interrupt flag. + * + * @param base FlexCAN base pointer. + * @param msgBuffIdx Index of the message buffer. + * @return the individual Message Buffer interrupt flag (true and false are the flag value). + */ +bool FLEXCAN_GetMsgBufStatusFlag(CAN_Type* base, uint8_t msgBufIdx); + +/*! + * @brief Clears the interrupt flag of the message buffers. + * + * @param base FlexCAN base pointer. + * @param msgBuffIdx Index of the message buffer. + */ +void FLEXCAN_ClearMsgBufStatusFlag(CAN_Type* base, uint32_t msgBufIdx); + +/*! + * @brief Enables error interrupt of the FlexCAN module. + * + * @param base FlexCAN base pointer. + * @param errorSrc The interrupt source. + * @param enable Choose enable or disable. + */ +void FLEXCAN_SetErrIntCmd(CAN_Type* base, uint32_t errorSrc, bool enable); + +/*! + * @brief Gets the FlexCAN module interrupt flag. + * + * @param base FlexCAN base pointer. + * @param errFlags Flexcan error flags. + * @return the individual Message Buffer interrupt flag (0 and 1 are the flag value) + */ +uint32_t FLEXCAN_GetErrStatusFlag(CAN_Type* base, uint32_t errFlags); + +/*! + * @brief Clears the interrupt flag of the FlexCAN module. + * + * @param base FlexCAN base pointer. + * @param errFlags The value to be written to the interrupt flag1 register. + */ +void FLEXCAN_ClearErrStatusFlag(CAN_Type* base, uint32_t errFlags); + +/*! + * @brief Get the error counter of FlexCAN module. + * + * @param base FlexCAN base pointer. + * @param txError Tx_Err_Counter pointer. + * @param rxError Rx_Err_Counter pointer. + */ +void FLEXCAN_GetErrCounter(CAN_Type* base, uint8_t* txError, uint8_t* rxError); + +/*@}*/ + +/*! + * @name Rx FIFO management functions + * @{ + */ + +/*! + * @brief Enables the Rx FIFO. + * + * @param base FlexCAN base pointer. + * @param numOfFilters The number of Rx FIFO filters + */ +void FLEXCAN_EnableRxFifo(CAN_Type* base, uint8_t numOfFilters); + +/*! + * @brief Disables the Rx FIFO. + * + * @param base FlexCAN base pointer. + */ +void FLEXCAN_DisableRxFifo(CAN_Type* base); + +/*! + * @brief Set the number of the Rx FIFO filters. + * + * @param base FlexCAN base pointer. + * @param number The number of Rx FIFO filters. + */ +void FLEXCAN_SetRxFifoFilterNum(CAN_Type* base, uint32_t numOfFilters); + +/*! + * @brief Set the FlexCAN Rx FIFO fields. + * + * @param base FlexCAN base pointer. + * @param idFormat The format of the Rx FIFO ID Filter Table Elements + * @param idFilterTable The ID filter table elements which contain RTR bit, IDE bit and RX message ID. + */ +void FLEXCAN_SetRxFifoFilter(CAN_Type* base, uint32_t idFormat, flexcan_id_table_t *idFilterTable); + +/*! + * @brief Gets the FlexCAN Rx FIFO data pointer. + * + * @param base FlexCAN base pointer. + * @return Rx FIFO data pointer. + */ +flexcan_msgbuf_t* FLEXCAN_GetRxFifoPtr(CAN_Type* base); + +/*! + * @brief Gets the FlexCAN Rx FIFO information. + * The return value indicates which Identifier Acceptance Filter + * (see Rx FIFO Structure) was hit by the received message. + * @param base FlexCAN base pointer. + * @return Rx FIFO filter number. + */ +uint16_t FLEXCAN_GetRxFifoInfo(CAN_Type* base); + +/*@}*/ + +/*! + * @name Rx Mask Setting functions + * @{ + */ + +/*! + * @brief Set the Rx masking mode. + * + * @param base FlexCAN base pointer. + * @param mode The FlexCAN Rx mask mode: can be set to global mode and individual mode. + */ +void FLEXCAN_SetRxMaskMode(CAN_Type* base, uint32_t mode); + +/*! + * @brief Set the remote trasmit request mask enablement. + * + * @param base FlexCAN base pointer. + * @param enable - true : Enable RTR matching judgement. + * false : Disable RTR matching judgement. + */ +void FLEXCAN_SetRxMaskRtrCmd(CAN_Type* base, uint32_t enable); + +/*! + * @brief Set the FlexCAN RX global mask. + * + * @param base FlexCAN base pointer. + * @param mask Rx Global mask. + */ +void FLEXCAN_SetRxGlobalMask(CAN_Type* base, uint32_t mask); + +/*! + * @brief Set the FlexCAN Rx individual mask for ID filtering in the Rx MBs and the Rx FIFO. + * + * @param base FlexCAN base pointer. + * @param msgBufIdx Index of the message buffer. + * @param mask Individual mask + */ +void FLEXCAN_SetRxIndividualMask(CAN_Type* base, uint32_t msgBufIdx, uint32_t mask); + +/*! + * @brief Set the FlexCAN RX Message Buffer BUF14 mask. + * + * @param base FlexCAN base pointer. + * @param mask Message Buffer BUF14 mask. + */ +void FLEXCAN_SetRxMsgBuff14Mask(CAN_Type* base, uint32_t mask); + +/*! + * @brief Set the FlexCAN RX Message Buffer BUF15 mask. + * + * @param base FlexCAN base pointer. + * @param mask Message Buffer BUF15 mask. + */ +void FLEXCAN_SetRxMsgBuff15Mask(CAN_Type* base, uint32_t mask); + +/*! + * @brief Set the FlexCAN RX Fifo global mask. + * + * @param base FlexCAN base pointer. + * @param mask Rx Fifo Global mask. + */ +void FLEXCAN_SetRxFifoGlobalMask(CAN_Type* base, uint32_t mask); + +/*@}*/ + +/*! + * @name Misc. Functions + * @{ + */ + +/*! + * @brief Enable/disable the FlexCAN self wakeup feature. + * + * @param base FlexCAN base pointer. + * @param lpfEnable The low pass filter for Rx self wakeup feature enablement. + * @param enable The self wakeup feature enablement. + */ +void FLEXCAN_SetSelfWakeUpCmd(CAN_Type* base, bool lpfEnable, bool enable); + +/*! + * @brief Enable/disable the FlexCAN self reception feature. + * + * @param base FlexCAN base pointer. + * @param enable - true : enable self reception feature. + * false : disable self reception feature. + */ +void FLEXCAN_SetSelfReceptionCmd(CAN_Type* base, bool enable); + +/*! + * @brief Enable/disable the enhance FlexCAN Rx vote. + * + * @param base FlexCAN base pointer. + * @param enable - true : Three samples are used to determine the value of the received bit. + * false : Just one sample is used to determine the bit value. + */ +void FLEXCAN_SetRxVoteCmd(CAN_Type* base, bool enable); + +/*! + * @brief Enable/disable the Auto Busoff recover feature. + * + * @param base FlexCAN base pointer. + * @param enable - true : Enable Auto Bus Off recover feature. + * false : Disable Auto Bus Off recover feature. + */ +void FLEXCAN_SetAutoBusOffRecoverCmd(CAN_Type* base, bool enable); + +/*! + * @brief Enable/disable the Time Sync feature. + * + * @param base FlexCAN base pointer. + * @param enable - true : Enable Time Sync feature. + * false : Disable Time Sync feature. + */ +void FLEXCAN_SetTimeSyncCmd(CAN_Type* base, bool enable); + +/*! + * @brief Enable/disable the Auto Remote Response feature. + * + * @param base FlexCAN base pointer. + * @param enable - true : Enable Auto Remote Response feature. + * false : Disable Auto Remote Response feature. + */ +void FLEXCAN_SetAutoRemoteResponseCmd(CAN_Type* base, bool enable); + +/*! + * @brief Enable/disable the Glitch Filter Width when FLEXCAN enters the STOP mode. + * + * @param base FlexCAN base pointer. + * @param filterWidth The Glitch Filter Width. + */ +static inline void FLEXCAN_SetGlitchFilterWidth(CAN_Type* base, uint8_t filterWidth) +{ + CAN_GFWR_REG(base) = filterWidth; +} + +/*! + * @brief Get the lowest inactive message buffer number. + * + * @param base FlexCAN base pointer. + * @return bit 22-16 : the lowest number inactive Mailbox. + * bit 14 : indicates whether the number content is valid or not. + * bit 13 : this bit indicates whether there is any inactive Mailbox. + */ +static inline uint32_t FLEXCAN_GetLowestInactiveMsgBuf(CAN_Type* base) +{ + return CAN_ESR2_REG(base); +} + +/*! + * @brief Set the Tx Arbitration Start Delay number. + * This function is used to optimize the transmit performance. + * For more information about to set this value, please refer to RM. + * + * @param base FlexCAN base pointer. + * @return tasd The lowest number inactive Mailbox. + */ +static inline void FLEXCAN_SetTxArbitrationStartDelay(CAN_Type* base, uint8_t tasd) +{ + assert(tasd < 32); + CAN_CTRL2_REG(base) = (CAN_CTRL2_REG(base) & ~CAN_CTRL2_TASD_MASK) | CAN_CTRL2_TASD(tasd); +} + +/*@}*/ + +#if defined(__cplusplus) +} +#endif + +/*! @}*/ + +#endif /* __FLEXCAN_H__ */ +/******************************************************************************* + * EOF + ******************************************************************************/ |