ext/hal/nxp/imx/drivers/flexcan.h

/*
 * 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"

/* Start of section using anonymous unions. */
#if defined(__ARMCC_VERSION)
  #pragma push
  #pragma anon_unions
#elif defined(__GNUC__)
  /* anonymous unions are enabled by default */
#elif defined(__IAR_SYSTEMS_ICC__)
  #pragma language=extended
#else
  #error Not supported compiler type
#endif

/*!
 * @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, /*!< Tx Warning interrupt source. */
    flexcanIntTxWarning = 0x02, /*!< Tx Warning interrupt source. */
    flexcanIntWakeUp    = 0x04, /*!< Wake Up interrupt source. */
    flexcanIntBusOff    = 0x08, /*!< Bus Off interrupt source.  */
    flexcanIntError     = 0x10, /*!< Error interrupt source. */
};

/*! @brief FlexCAN error interrupt flags. */
enum _flexcan_status_flag
{
    flexcanStatusSynch        = CAN_ESR1_SYNCH_MASK,    /*!< Bus Synchronized flag. */
    flexcanStatusTxWarningInt = CAN_ESR1_TWRN_INT_MASK, /*!< Tx Warning initerrupt flag. */
    flexcanStatusRxWarningInt = CAN_ESR1_RWRN_INT_MASK, /*!< Tx Warning initerrupt flag. */
    flexcanStatusBit1Err      = CAN_ESR1_BIT1_ERR_MASK, /*!< Bit0 Error flag. */
    flexcanStatusBit0Err      = CAN_ESR1_BIT0_ERR_MASK, /*!< Bit1 Error flag. */
    flexcanStatusAckErr       = CAN_ESR1_ACK_ERR_MASK,  /*!< Ack Error flag. */
    flexcanStatusCrcErr       = CAN_ESR1_CRC_ERR_MASK,  /*!< CRC Error flag. */
    flexcanStatusFrameErr     = CAN_ESR1_FRM_ERR_MASK,  /*!< Frame Error flag. */
    flexcanStatusStuffingErr  = CAN_ESR1_STF_ERR_MASK,  /*!< Stuffing Error flag. */
    flexcanStatusTxWarning    = CAN_ESR1_TX_WRN_MASK,   /*!< Tx Warning flag. */
    flexcanStatusRxWarning    = CAN_ESR1_RX_WRN_MASK,   /*!< Rx Warning flag. */
    flexcanStatusIdle         = CAN_ESR1_IDLE_MASK,     /*!< FlexCAN Idle flag. */
    flexcanStatusTransmitting = CAN_ESR1_TX_MASK,       /*!< Trasmitting flag. */
    flexcanStatusFltConf      = CAN_ESR1_FLT_CONF_MASK, /*!< Fault Config flag. */
    flexcanStatusReceiving    = CAN_ESR1_RX_MASK,       /*!< Receiving flag. */
    flexcanStatusBusOff       = CAN_ESR1_BOFF_INT_MASK, /*!< Bus Off interrupt flag. */
    flexcanStatusError        = CAN_ESR1_ERR_INT_MASK,  /*!< Error interrupt flag. */
    flexcanStatusWake         = CAN_ESR1_WAK_INT_MASK,  /*!< Wake Up interrupt flag. */
};

/*! @brief The id filter element type selection. */
enum _flexcan_rx_fifo_id_element_format
{
    flexcanRxFifoIdElementFormatA = 0x0, /*!< One full ID (standard and extended) per ID Filter Table element. */
    flexcanRxFifoIdElementFormatB = 0x1, /*!< Two full standard IDs or two partial 14-bit (standard and extended) IDs per ID Filter Table element. */
    flexcanRxFifoIdElementFormatC = 0x2, /*!< Four partial 8-bit Standard IDs per ID Filter Table element. */
    flexcanRxFifoIdElementFormatD = 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 _flexcan_id_table
{
    uint32_t *idFilter;   /*!< Rx FIFO ID filter elements. */
    bool isRemoteFrame;   /*!< Remote frame. */
    bool isExtendedFrame; /*!< Extended frame. */
} 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 reserved1 : 1;
            uint32_t code      : 4;
            uint32_t reserved2 : 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 2. */
    uint32_t propSeg;    /*!< Propagation segment. */
} flexcan_timing_t;

/*! @brief FlexCAN module initialization 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 initialization structure.
 *
 * @param base CAN base pointer.
 * @param initConfig CAN initialization structure (see @ref flexcan_init_config_t structure).
 */
void FLEXCAN_Init(CAN_Type* base, const 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 FlexCAN 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 (See @ref flexcan_timing_t structure).
 */
void FLEXCAN_SetTiming(CAN_Type* base, const 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 Enable/Disable Transmit Abort feature.
 *               - 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 Enable/Disable local transmit periority.
 *               - 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 Set Rx matching process 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 msgBufIdx Index of the message buffer
 * @return - true: Lock Rx Message Buffer successful.
 *         - false: Lock Rx Message Buffer 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 msgBufIdx Index of the message buffer.
 * @param enable Enables/Disables interrupt.
 *               - true: Enable Message Buffer interrupt.
 *               - disable: Disable Message Buffer interrupt.
 */
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 msgBufIdx Index of the message buffer.
 * @retval true: Message Buffer Interrupt is pending.
 * @retval false: There is no Message Buffer Interrupt.
 */
bool FLEXCAN_GetMsgBufStatusFlag(CAN_Type* base, uint8_t msgBufIdx);

/*!
 * @brief Clears the interrupt flag of the message buffers.
 *
 * @param base FlexCAN base pointer.
 * @param msgBufIdx 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 (see @ref _flexcan_interrutpt enumeration).
 * @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 (see @ref _flexcan_status_flag enumeration).
 * @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 (see @ref _flexcan_status_flag enumeration).
 */
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 numOfFilters 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 (see @ref _flexcan_rx_mask_mode enumeration).
 */
void FLEXCAN_SetRxMaskMode(CAN_Type* base, uint32_t mode);

/*!
 * @brief Set the remote trasmit request mask enablement.
 *
 * @param base FlexCAN base pointer.
 * @param enable Enable/Disable remote trasmit request mask.
 *               - true: Enable RTR matching judgement.
 *               - false: Disable RTR matching judgement.
 */
void FLEXCAN_SetRxMaskRtrCmd(CAN_Type* base, bool 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 Enable/Disable self reception feature.
 *               - 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 Enable/Disable FlexCAN Rx vote mechanism
 *               - 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 Enable/Disable Auto Busoff Recover
 *               - 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 Enable/Disable the Time Sync
 *               - 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 Enable/Disable the Auto Remote Response feature
 *               - 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, see the Chip Reference Manual.
 *
 * @param base FlexCAN base pointer.
 * @param 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

/*! @}*/

#if defined(__ARMCC_VERSION)
  #pragma pop
#elif defined(__GNUC__)
  /* leave anonymous unions enabled */
#elif defined(__IAR_SYSTEMS_ICC__)
  #pragma language=default
#else
  #error Not supported compiler type
#endif

#endif /* __FLEXCAN_H__ */
/*******************************************************************************
 * EOF
 ******************************************************************************/