text: /*
   * 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
   ******************************************************************************/
  