drivers/esai/fsl_esai.h

/*
 * Copyright (c) 2016, Freescale Semiconductor, Inc.
 * Copyright 2016-2020 NXP
 * All rights reserved.
 *
 * SPDX-License-Identifier: BSD-3-Clause
 */

#ifndef _FSL_ESAI_H_
#define _FSL_ESAI_H_

#include "fsl_common.h"

/*!
 * @addtogroup esai
 * @{
 */

/*******************************************************************************
 * Definitions
 ******************************************************************************/

/*! @name Driver version */
/*@{*/
#define FSL_ESAI_DRIVER_VERSION (MAKE_VERSION(2, 1, 1)) /*!< Version 2.1.1 */
/*@}*/

/*! @brief ESAI return status, _esai_status_t*/
enum
{
    kStatus_ESAI_TxBusy    = MAKE_STATUS(kStatusGroup_ESAI, 0), /*!< ESAI Tx is busy. */
    kStatus_ESAI_RxBusy    = MAKE_STATUS(kStatusGroup_ESAI, 1), /*!< ESAI Rx is busy. */
    kStatus_ESAI_TxError   = MAKE_STATUS(kStatusGroup_ESAI, 2), /*!< ESAI Tx FIFO error. */
    kStatus_ESAI_RxError   = MAKE_STATUS(kStatusGroup_ESAI, 3), /*!< ESAI Rx FIFO error. */
    kStatus_ESAI_QueueFull = MAKE_STATUS(kStatusGroup_ESAI, 4), /*!< ESAI transfer queue is full. */
    kStatus_ESAI_TxIdle    = MAKE_STATUS(kStatusGroup_ESAI, 5), /*!< ESAI Tx is idle */
    kStatus_ESAI_RxIdle    = MAKE_STATUS(kStatusGroup_ESAI, 6)  /*!< ESAI Rx is idle */
};

/*! @brief Define the ESAI bus type */
typedef enum _esai_mode
{
    kESAI_NormalMode = 0x0U, /*!< Use normal mode.*/
    kESAI_NetworkMode        /*!< Network mode. */
} esai_mode_t;

/*! @brief Define the ESAI bus type */
typedef enum _esai_protocol
{
    kESAI_BusLeftJustified = 0x0U, /*!< Uses left justified format.*/
    kESAI_BusRightJustified,       /*!< Uses right justified format. */
    kESAI_BusI2S,                  /*!< Uses I2S format. */
    kESAI_BusPCMA,                 /*!< Uses I2S PCM A format.*/
    kESAI_BusPCMB,                 /*!< Uses I2S PCM B format. */
    kESAI_BusTDM,                  /*!< Use TDM mode */
    kESAI_BusCustomerNormal,       /*!< Customer defined normal mode */
    kESAI_BusCustomerNetwork       /*!< Customer defined network mode */
} esai_protocol_t;

/*! @brief Master or slave mode */
typedef enum _esai_master_slave
{
    kESAI_Master = 0x0U, /*!< Master mode */
    kESAI_Slave  = 0x1U  /*!< Slave mode */
} esai_master_slave_t;

/*! @brief Synchronous or asynchronous mode */
typedef enum _esai_sync_mode
{
    kESAI_ModeAsync = 0x0U, /*!< Asynchronous mode */
    kESAI_ModeSync,         /*!< Synchronous mode (with receiver or transmit) */
} esai_sync_mode_t;

/*! @brief Mater clock source */
typedef enum _esai_hclk_source
{
    kESAI_HckSourceInternal = 0x0U, /* HCK from ESAI internal clock, gnerally 133Mhz */
    kESAI_HckSourceExternal = 0x1U  /* HCK from external, soc specific, can be an audio PLL. */
} esai_hclk_source_t;

/*! @brief Bit clock source */
typedef enum _esai_clock_polarity
{
    kESAI_ClockActiveHigh = 0x0U, /*!< Clock active while high */
    kESAI_ClockActiveLow,         /*!< Clock actie while low */
} esai_clock_polarity_t;

/*! @brief ESAI shifter register shift direction */
typedef enum _esai_shift_direction
{
    kESAI_ShifterMSB = 0x0, /*!< Data is shifted MSB first */
    kESAI_ShifterLSB = 0x1  /*!< Data is shifted LSB first */
} esai_shift_direction_t;

/*! @brief ESAI clock direction */
typedef enum _esai_clock_direction
{
    kESAI_ClockInput  = 0x0, /*!< Clock direction is input */
    kESAI_ClockOutput = 0x1  /*!< Clock direction is output */
} esai_clock_direction_t;

/*! @brief The ESAI interrupt enable flag, _esai_interrupt_enable_t */
enum
{
    kESAI_LastSlotInterruptEnable =
        ESAI_TCR_TLIE_MASK, /*!< Enable interrupt at the beginning of last slot of frame in network mode */
    kESAI_TransmitInterruptEnable     = ESAI_TCR_TIE_MASK,   /*!< Transmit/receive even slot data interrupt */
    kESAI_EvenSlotDataInterruptEnable = ESAI_TCR_TEDIE_MASK, /*!< Transmit/receive even slot data interrupt */
    kESAI_ExceptionInterruptEnable    = ESAI_TCR_TEIE_MASK,  /*!< FIFO error flag */
};

/*! @brief The ESAI status flag, _esai_flags*/
enum
{
    kESAI_TransmitInitFlag          = ESAI_ESR_TINIT_MASK, /*!< Indicates transmit FIFO is writing the first word */
    kESAI_ReceiveFIFOFullFlag       = ESAI_ESR_RFF_MASK,   /*!< Receive FIFO full flag */
    kESAI_TransmitFIFOEmptyFlag     = ESAI_ESR_TFE_MASK,   /*!< Transmit FIFO empty */
    kESAI_TransmitLastSlotFlag      = ESAI_ESR_TLS_MASK,   /*!< Transmit last slot */
    kESAI_TransmitDataExceptionFlag = ESAI_ESR_TDE_MASK,   /*!< Transmit data exception */
    kESAI_TransmitEvenDataFlag      = ESAI_ESR_TED_MASK,   /*!< Transmit even data */
    kESAI_TransmitDataFlag          = ESAI_ESR_TD_MASK,    /*!< Transmit data */
    kESAI_ReceiveLastSlot           = ESAI_ESR_RLS_MASK,   /*!< Receive last slot */
    kESAI_ReceiveDataException      = ESAI_ESR_RDE_MASK,   /*!< Receive data exception */
    kESAI_ReceiveEvenData           = ESAI_ESR_RED_MASK,   /*!< Receive even data */
    kESAI_ReceiveData               = ESAI_ESR_RD_MASK,    /*!< Receive data */
};

/*! @brief SAI interface port status flag, _esai_sai_flags*/
enum
{
    kESAI_TransmitOddRegEmpty   = ESAI_SAISR_TODFE_MASK, /*!< Enabled transmitter register empty at odd slot */
    kESAI_TransmitEvenRegEmpty  = ESAI_SAISR_TEDE_MASK,  /*!< Enabled transmitter register empty at even slot */
    kESAI_TransmitRegEmpty      = ESAI_SAISR_TDE_MASK,  /*!< All data in enabled transmitter regsiter send to shifter */
    kESAI_TransmitUnderrunError = ESAI_SAISR_TUE_MASK,  /*!< Serial shifter empty  and a transmit slot begins */
    kESAI_TransmitFrameSync     = ESAI_SAISR_TFS_MASK,  /*!< A transmit frame sync occurred in the current time slot */
    kESAI_RecceiveOddRegFull    = ESAI_SAISR_RODF_MASK, /*!< Enabled receiver register full at odd slot */
    kESAI_ReceiveEvenRegFull    = ESAI_SAISR_RDF_MASK,  /*!< Enabled receiver register full at even slot */
    kESAI_RecceiveOverrunError  = ESAI_SAISR_ROE_MASK,  /*!< Receive data register overrun flag */
    kESAI_ReceiveFrameSync      = ESAI_SAISR_RFS_MASK,  /*!< Receive frame sync flag, indicate a frame sync occurs */
    kESAI_SerialInputFlag2      = ESAI_SAISR_IF2_MASK,  /*!< Serial input flag 2 */
    kESAI_SerialInputFlag1      = ESAI_SAISR_IF1_MASK,  /*!< Serial in out flag 1 */
    kESAI_SerialInputFlag0      = ESAI_SAISR_IF0_MASK   /*!< Serial input flag 0 */
};

/*! @brief Audio sample rate */
typedef enum _esai_sample_rate
{
    kESAI_SampleRate8KHz    = 8000U,  /*!< Sample rate 8000 Hz */
    kESAI_SampleRate11025Hz = 11025U, /*!< Sample rate 11025 Hz */
    kESAI_SampleRate12KHz   = 12000U, /*!< Sample rate 12000 Hz */
    kESAI_SampleRate16KHz   = 16000U, /*!< Sample rate 16000 Hz */
    kESAI_SampleRate22050Hz = 22050U, /*!< Sample rate 22050 Hz */
    kESAI_SampleRate24KHz   = 24000U, /*!< Sample rate 24000 Hz */
    kESAI_SampleRate32KHz   = 32000U, /*!< Sample rate 32000 Hz */
    kESAI_SampleRate44100Hz = 44100U, /*!< Sample rate 44100 Hz */
    kESAI_SampleRate48KHz   = 48000U, /*!< Sample rate 48000 Hz */
    kESAI_SampleRate96KHz   = 96000U  /*!< Sample rate 96000 Hz */
} esai_sample_rate_t;

/*! @brief Audio word width */
typedef enum _esai_word_width
{
    kESAI_WordWidth8bits  = 8U,  /*!< Audio data width 8 bits */
    kESAI_WordWidth16bits = 16U, /*!< Audio data width 16 bits */
    kESAI_WordWidth24bits = 24U, /*!< Audio data width 24 bits */
    kESAI_WordWidth32bits = 32U  /*!< Audio data width 32 bits */
} esai_word_width_t;

/*! @brief esai slot word length */
typedef enum _esai_slot_format
{
    kESAI_SlotLen8WordLen8   = 0x0U,  /*!< Slot length 8 bits, word length 8 bits */
    kESAI_SlotLen12WordLen8  = 0x04U, /*!< Slot length 12 bits, word length 8 bits */
    kESAI_SlotLen12WordLen12 = 0x01U, /*!< Slot length 12 bits, word length 12 bits */
    kESAI_SlotLen16WordLen8  = 0x08U, /*!< Slot length 16 bits, word length 8 bits */
    kESAI_SlotLen16WordLen12 = 0x05U, /*!< Slot length 16 bits, word length 12 bits */
    kESAI_SlotLen16WordLen16 = 0x02U, /*!< Slot length 16 bits, word length 16 bits */
    kESAI_SlotLen20WordLen8  = 0x0CU, /*!< Slot length 20 bits, word length 8 bits */
    kESAI_SlotLen20WordLen12 = 0x09U, /*!< Slot length 20 bits, word length 12 bits */
    kESAI_SlotLen20WordLen16 = 0x06U, /*!< Slot length 20 bits, word length 16 bits */
    kESAI_SlotLen20WordLen20 = 0x03U, /*!< Slot length 20 bits, word length 20 bits */
    kESAI_SlotLen24WordLen8  = 0x10U, /*!< Slot length 24 bits, word length 8 bits */
    kESAI_SlotLen24WordLen12 = 0x0DU, /*!< Slot length 24 bits, word length 12 bits */
    kESAI_SlotLen24WordLen16 = 0x0AU, /*!< Slot length 24 bits, word length 16 bits */
    kESAI_SlotLen24WordLen20 = 0x07U, /*!< Slot length 24 bits, word length 20 bits */
    kESAI_SlotLen24WordLen24 = 0x1EU, /*!< Slot length 24 bits, word length 24 bits */
    kESAI_SlotLen32WordLen8  = 0x18U, /*!< Slot length 32 bits, word length 8 bits */
    kESAI_SlotLen32WordLen12 = 0x15U, /*!< Slot length 32 bits, word length 12 bits */
    kESAI_SlotLen32WordLen16 = 0x12U, /*!< Slot length 32 bits, word length 16 bits */
    kESAI_SlotLen32WordLen20 = 0x0FU, /*!< Slot length 32 bits, word length 20 bits */
    kESAI_SlotLen32WordLen24 = 0x1FU  /*!< Slot length 32 bits, word length 24 bits */
} esai_slot_format_t;

/*! @brief ESAI customer defined audio format */
typedef struct _esai_customer_protocol
{
    esai_mode_t mode;                      /*!< ESAI mode, network, normal or on demand mode */
    esai_shift_direction_t shiftDirection; /*!< Data shift direction, MSB or LSB */
    bool fsEarly;                          /*!< If the frame sync one bit early */
    bool ifZeroPading;                     /*!< If padding zero */
    bool dataAlign;                        /*!< Data left aligned or right aligned */
    bool fsOneBit;                         /*!< If the frame sync one word length or one bit length */
    uint8_t slotNum;                       /*!< Slot number for the audio format */
} esai_customer_protocol_t;

/*! @brief ESAI user configuration structure */
typedef struct _esai_config
{
    esai_sync_mode_t syncMode;             /*!< ESAI sync mode, control Tx/Rx clock sync */
    esai_protocol_t txProtocol;            /*!< Use which kind of protocol */
    esai_protocol_t rxProtocol;            /*!< Use which kind of protocol */
    esai_customer_protocol_t txCustomer;   /*!< Audio protocol customer uses for tx */
    esai_customer_protocol_t rxCustomer;   /*!< Audio protocol customer uses for rx */
    esai_master_slave_t master;            /*!< Master or slave */
    esai_clock_direction_t txHckDirection; /*!< Tx HCK direction, input or output */
    esai_clock_direction_t rxHckDirection; /*!< Rx HCK direction, input or output */
    esai_hclk_source_t txHckSource;        /*!< Tx HCK input clock source */
    esai_hclk_source_t rxHckSource;        /*!< Rx HCK input clock source */
    esai_hclk_source_t txHckOutputSource;  /*!< Tx HCK pin output clock source */
    esai_hclk_source_t rxHckOutputSource;  /*!< Rx HCK pin output clock source */
    esai_clock_polarity_t txHckPolarity;   /*!< Tx HCK polarity */
    esai_clock_polarity_t txFsPolarity;    /*!< Tx frame sync polarity */
    esai_clock_polarity_t txSckPolarity;   /*!< Tx bit clock polarity */
    esai_clock_polarity_t rxHckPolarity;   /*!< Rx HCK polarity */
    esai_clock_polarity_t rxFsPolarity;    /*!< Rx frame sync polarity */
    esai_clock_polarity_t rxSckPolarity;   /*!< Rx bit clock polarity */
    uint8_t txWatermark;                   /*!< Tx transfer watermark */
    uint8_t rxWatermark;                   /*!< Rx receive watermark */
} esai_config_t;

/*!@brief ESAI transfer queue size, user can refine it according to use case. */
#define ESAI_XFER_QUEUE_SIZE (4U)

/*! @brief esai transfer format */
typedef struct _esai_format
{
    esai_sample_rate_t sampleRate_Hz; /*!< Sample rate of audio data */
    esai_slot_format_t slotType;      /*!< Slot format for audio format */
    uint8_t sectionMap; /*!< The sections enabled, 0x1 means TE0 enabled, 0x2 means TE1 enabled, 0x4 means TE2, etc  */
} esai_format_t;

/*! @brief ESAI transfer structure */
typedef struct _esai_transfer
{
    uint8_t *data;   /*!< Data start address to transfer. */
    size_t dataSize; /*!< Transfer size. */
} esai_transfer_t;

typedef struct _esai_handle esai_handle_t;

/*! @brief ESAI transfer callback prototype */
typedef void (*esai_transfer_callback_t)(ESAI_Type *base, esai_handle_t *handle, status_t status, void *userData);

/*! @brief ESAI handle structure */
struct _esai_handle
{
    uint32_t state;                                  /*!< Transfer status */
    esai_transfer_callback_t callback;               /*!< Callback function called at transfer event*/
    void *userData;                                  /*!< Callback parameter passed to callback function*/
    uint8_t bitWidth;                                /*!< Bit width for transfer, 8/16/24/32 bits */
    uint8_t slotLen;                                 /*!< Slot length of the audio data */
    uint8_t sectionMap;                              /*!< Enabled section map */
    esai_transfer_t esaiQueue[ESAI_XFER_QUEUE_SIZE]; /*!< Transfer queue storing queued transfer */
    size_t transferSize[ESAI_XFER_QUEUE_SIZE];       /*!< Data bytes need to transfer */
    volatile uint8_t queueUser;                      /*!< Index for user to queue transfer */
    volatile uint8_t queueDriver;                    /*!< Index for driver to get the transfer data and size */
    uint8_t watermark;                               /*!< Watermark value */
};

/*******************************************************************************
 * API
 ******************************************************************************/

#if defined(__cplusplus)
extern "C" {
#endif /*_cplusplus*/

/*!
 * @name Initialization and deinitialization
 * @{
 */

/*!
 * @brief Initializes the ESAI peripheral.
 *
 * Ungates the ESAI clock, resets the module, and configures ESAI with a configuration structure.
 * The configuration structure can be custom filled or set with default values by
 * ESAI_GetDefaultConfig().
 *
 * @note  This API should be called at the beginning of the application to use
 * the ESAI driver. Otherwise, accessing the ESAI module can cause a hard fault
 * because the clock is not enabled.
 *
 * @param base ESAI base pointer
 * @param config ESAI configuration structure.
 */
void ESAI_Init(ESAI_Type *base, esai_config_t *config);

/*!
 * @brief  Sets the ESAI configuration structure to default values.
 *
 * This API initializes the configuration structure for use in ESAI_TxConfig().
 * The initialized structure can remain unchanged in ESAI_Init(), or it can be modified
 *  before calling ESAI_Init().
 *
 * @param config pointer to master configuration structure
 */
void ESAI_GetDefaultConfig(esai_config_t *config);

/*!
 * @brief De-initializes the ESAI peripheral.
 *
 * This API gates the ESAI clock. The ESAI module can't operate unless ESAI_Init
 * is called to enable the clock.
 *
 * @param base ESAI base pointer
 */
void ESAI_Deinit(ESAI_Type *base);

/*!
 * @brief Enable/Disable the ESAI peripheral internal logic.
 *
 * @param base ESAI base pointer
 * @param enable True meanse enable, false means disable.
 */
static inline void ESAI_Enable(ESAI_Type *base, bool enable)
{
    if (enable)
    {
        base->ECR |= ESAI_ECR_ESAIEN_MASK;
    }
    else
    {
        base->ECR &= ~ESAI_ECR_ESAIEN_MASK;
    }
}

/*!
 * @brief Reset ESAI internal logic.
 *
 * This API only resets the core logic, including the configuration registers, but not the ESAI FIFOs, users
 * still needs to reset the ESAI fifo by calling ESAI_TxResetFIFO and ESAI_RxResetFIFO.
 *
 * @param base ESAI base pointer
 */
static inline void ESAI_Reset(ESAI_Type *base)
{
    base->ECR |= ESAI_ECR_ERST_MASK;
    base->ECR &= ~ESAI_ECR_ERST_MASK;
}

/*!
 * @brief Reset ESAI all tx sections.
 *
 * This API only resets the core logic of tx and all tx sections.
 *
 * @param base ESAI base pointer
 */
void ESAI_TxReset(ESAI_Type *base);

/*!
 * @brief Reset ESAI all rx sections.
 *
 * This API only resets the core logic of rx and all rx sections.
 *
 * @param base ESAI base pointer
 */
void ESAI_RxReset(ESAI_Type *base);

/*!
 * @brief Resets the ESAI Tx FIFO.
 *
 * This function only resets the ESAI Tx FIFO.
 *
 * @param base ESAI base pointer
 */
static inline void ESAI_TxResetFIFO(ESAI_Type *base)
{
    base->TFCR |= ESAI_TFCR_TFR_MASK;
}

/*!
 * @brief Resets the ESAI Rx FIFO.
 *
 * This function only resets the ESAI Rx FIFO.
 *
 * @param base ESAI base pointer
 */
static inline void ESAI_RxResetFIFO(ESAI_Type *base)
{
    base->RFCR |= ESAI_TFCR_TFR_MASK;
}

/*!
 * @brief Enables/disables ESAI Tx.
 *
 * @param base ESAI base pointer
 * @param sectionMap Which sections need to be enabled. 0 means all section disabled. This parameter can be a
 * combination of each sections, every section N is 2^N in section map.
 */
void ESAI_TxEnable(ESAI_Type *base, uint8_t sectionMap);

/*!
 * @brief Enables/disables ESAI Rx.
 *
 * @param base ESAI base pointer
 * @param sectionMap Which sections need to be enabled. 0 means all section disabled. This parameter can be a
 * combination of each sections, every section N is 2^N in section map.
 */
void ESAI_RxEnable(ESAI_Type *base, uint8_t sectionMap);

/*!
 * @brief Enables/disables ESAI Tx FIFO.
 *
 * @param base ESAI base pointer
 * @param enable True means enable ESAI Tx, false means disable.
 */
static inline void ESAI_TxEnableFIFO(ESAI_Type *base, bool enable)
{
    if (enable)
    {
        base->TFCR |= ESAI_TFCR_TFE_MASK;
    }
    else
    {
        base->TFCR &= ~ESAI_TFCR_TFE_MASK;
    }
}

/*!
 * @brief Enables/disables ESAI Rx FIFO.
 *
 * @param base ESAI base pointer
 * @param enable True means enable ESAI Rx, false means disable.
 */
static inline void ESAI_RxEnableFIFO(ESAI_Type *base, bool enable)
{
    if (enable)
    {
        base->RFCR |= ESAI_RFCR_RFE_MASK;
    }
    else
    {
        base->RFCR &= ~ESAI_RFCR_RFE_MASK;
    }
}

/*!
 * @brief Set ESAI Tx slot mask value.
 *
 * @param base ESAI base pointer
 * @param slot Slot number need to be masked for Tx.
 */
static inline void ESAI_TxSetSlotMask(ESAI_Type *base, uint32_t slot)
{
    base->TSMA = (slot & 0xFFFFU);
    base->TSMB = (slot & 0xFFFF0000U) >> 16U;
}

/*!
 * @brief Set ESAI Rx slot mask value.
 *
 * @param base ESAI base pointer
 * @param slot Slot number need to be masked for Rx
 */
static inline void EASI_RxSetSlotMask(ESAI_Type *base, uint32_t slot)
{
    base->RSMA = (slot & 0xFFFFU);
    base->RSMB = (slot & 0xFFFF0000U) >> 16U;
}

/*!
 * @brief Get the data length and slot length from the input.
 *
 * This API sets the audio protocol defined by users.
 *
 * @param slotFormat Slot type.
 * @param slotLen Pointer to the return slot length value.
 * @param dataLen Pointer to the return data length in a slot.
 */
void ESAI_AnalysisSlot(esai_slot_format_t slotFormat, uint8_t *slotLen, uint8_t *dataLen);

/*!
 * @brief Get the instance number for ESAI.
 *
 * @param base ESAI base pointer.
 */
uint32_t ESAI_GetInstance(ESAI_Type *base);

/*! @} */

/*!
 * @name Status
 * @{
 */

/*!
 * @brief Gets the ESAI status flag state.
 *
 * @param base ESAI base pointer
 * @return ESAI staus flag value. Use status flag to AND _esai_flags to get the related status.
 */
static inline uint32_t ESAI_GetStatusFlag(ESAI_Type *base)
{
    return base->ESR;
}

/*!
 * @brief Gets the ESAI SAI port status flag state.
 *
 * @param base ESAI base pointer
 * @return ESAI staus flag value. Use status flag to AND _esai_sai_flags to get the related status.
 */
static inline uint32_t ESAI_GetSAIStatusFlag(ESAI_Type *base)
{
    return base->SAISR;
}

/*!
 * @brief Gets the ESAI Tx FIFO state.
 *
 * @param base ESAI base pointer
 * @return ESAI Tx status flag value.
 */
static inline uint32_t ESAI_GetTxFIFOStatus(ESAI_Type *base)
{
    return base->TFSR;
}

/*!
 * @brief Gets the ESAI Tx status flag state.
 *
 * @param base ESAI base pointer
 * @return ESAI Rx status flag value.
 */
static inline uint32_t ESAI_GetRxFIFOStatus(ESAI_Type *base)
{
    return base->RFSR;
}

/*! @} */

/*!
 * @name Interrupts
 * @{
 */

/*!
 * @brief Enables ESAI Tx interrupt requests.
 *
 * @param base ESAI base pointer
 * @param mask interrupt source. The parameter can be a combination of elements in _esai_interrupt_enable_t.
 */
static inline void ESAI_TxEnableInterrupts(ESAI_Type *base, uint32_t mask)
{
    base->TCR |= mask;
}

/*!
 * @brief Enables ESAI Rx interrupt requests.
 *
 * @param base ESAI base pointer
 * @param mask interrupt source. The parameter can be a combination of elements in _esai_interrupt_enable_t.
 */
static inline void ESAI_RxEnableInterrupts(ESAI_Type *base, uint32_t mask)
{
    base->RCR |= mask;
}

/*!
 * @brief Disables ESAI Tx interrupt requests.
 *
 * @param base ESAI base pointer
 * @param mask interrupt source. The parameter can be a combination of elements in _esai_interrupt_enable_t.
 */
static inline void ESAI_TxDisableInterrupts(ESAI_Type *base, uint32_t mask)
{
    base->TCR &= (~mask);
}

/*!
 * @brief Disables ESAI Rx interrupt requests.
 *
 * @param base ESAI base pointer
 * @param mask interrupt source. The parameter can be a combination of elements in _esai_interrupt_enable_t.
 */
static inline void ESAI_RxDisableInterrupts(ESAI_Type *base, uint32_t mask)
{
    base->RCR &= (~mask);
}

/*! @} */

/*!
 * @name DMA Control
 * @{
 */

/*!
 * @brief  Gets the ESAI Tx data register address.
 *
 * This API is used to provide a transfer address for ESAI DMA transfer configuration.
 *
 * @param base ESAI base pointer.
 * @return data register address.
 */
static inline uint32_t ESAI_TxGetDataRegisterAddress(ESAI_Type *base)
{
    return (uint32_t)(&(base->ETDR));
}

/*!
 * @brief  Gets the ESAI Rx data register address.
 *
 * This API is used to provide a transfer address for ESAI DMA transfer configuration.
 *
 * @param base ESAI base pointer.
 * @return data register address.
 */
static inline uint32_t ESAI_RxGetDataRegisterAddress(ESAI_Type *base)
{
    return (uint32_t)(&(base->ERDR));
}

/*! @} */

/*!
 * @name Bus Operations
 * @{
 */

/*!
 * @brief Configures the ESAI Tx audio format.
 *
 * The audio format can be changed at run-time. This function configures the sample rate and audio data
 * format to be transferred.
 *
 * @param base ESAI base pointer.
 * @param format Pointer to ESAI audio data format structure.
 * @param hckClockHz HCK clock frequency in Hz.
 * @param hckSourceClockHz HCK source clock frequency in Hz.
 */
void ESAI_TxSetFormat(ESAI_Type *base, esai_format_t *format, uint32_t hckClockHz, uint32_t hckSourceClockHz);

/*!
 * @brief Configures the ESAI Rx audio format.
 *
 * The audio format can be changed at run-time. This function configures the sample rate and audio data
 * format to be transferred.
 *
 * @param base ESAI base pointer.
 * @param format Pointer to ESAI audio data format structure.
 * @param hckClockHz HCK clock frequency in Hz.
 * @param hckSourceClockHz HCK source clock frequency in Hz.
 */
void ESAI_RxSetFormat(ESAI_Type *base, esai_format_t *format, uint32_t hckClockHz, uint32_t hckSourceClockHz);

/*!
 * @brief Sends data using a blocking method.
 *
 * @note This function blocks by polling until data is ready to be sent.
 *
 * @param base ESAI base pointer.
 * @param bitWidth How many bits in a audio word, usually 8/16/24 bits.
 * @param buffer Pointer to the data to be written.
 * @param size Bytes to be written.
 */
void ESAI_WriteBlocking(ESAI_Type *base, uint32_t bitWidth, uint8_t *buffer, uint32_t size);

/*!
 * @brief Writes data into ESAI FIFO.
 *
 * @param base ESAI base pointer.
 * @param data Data needs to be written.
 */
static inline void ESAI_WriteData(ESAI_Type *base, uint32_t data)
{
    base->ETDR = data;
}

/*!
 * @brief Receives data using a blocking method.
 *
 * @note This function blocks by polling until data is ready to be sent.
 *
 * @param base ESAI base pointer.
 * @param bitWidth How many bits in a audio word, usually 8/16/24 bits.
 * @param buffer Pointer to the data to be read.
 * @param size Bytes to be read.
 */
void ESAI_ReadBlocking(ESAI_Type *base, uint32_t bitWidth, uint8_t *buffer, uint32_t size);

/*!
 * @brief Reads data from ESAI FIFO.
 *
 * @param base ESAI base pointer.
 * @param channel Data channel used.
 * @return Data in ESAI FIFO.
 */
static inline uint32_t ESAI_ReadData(ESAI_Type *base, uint32_t channel)
{
    return base->ERDR;
}

/*! @} */

/*!
 * @name Transactional
 * @{
 */

/*!
 * @brief Initializes the ESAI Tx handle.
 *
 * This function initializes the Tx handle for ESAI Tx transactional APIs. Call
 * this function one time to get the handle initialized.
 *
 * @param base ESAI base pointer
 * @param handle ESAI handle pointer.
 * @param callback pointer to user callback function
 * @param userData user parameter passed to the callback function
 */
void ESAI_TransferTxCreateHandle(ESAI_Type *base,
                                 esai_handle_t *handle,
                                 esai_transfer_callback_t callback,
                                 void *userData);

/*!
 * @brief Initializes the ESAI Rx handle.
 *
 * This function initializes the Rx handle for ESAI Rx transactional APIs. Call
 * this function one time to get the handle initialized.
 *
 * @param base ESAI base pointer.
 * @param handle ESAI handle pointer.
 * @param callback pointer to user callback function
 * @param userData user parameter passed to the callback function
 */
void ESAI_TransferRxCreateHandle(ESAI_Type *base,
                                 esai_handle_t *handle,
                                 esai_transfer_callback_t callback,
                                 void *userData);

/*!
 * @brief Configures the ESAI Tx audio format.
 *
 * The audio format can be changed at run-time. This function configures the sample rate and audio data
 * format to be transferred.
 *
 * @param base ESAI base pointer.
 * @param handle ESAI handle pointer.
 * @param format Pointer to ESAI audio data format structure.
 * @param hckClockHz HCK clock frequency in Hz.
 * @param hckSourceClockHz HCK clock source frequency in Hz.
 * @return Status of this function. Return value is one of status_t.
 */
status_t ESAI_TransferTxSetFormat(
    ESAI_Type *base, esai_handle_t *handle, esai_format_t *format, uint32_t hckClockHz, uint32_t hckSourceClockHz);

/*!
 * @brief Configures the ESAI Rx audio format.
 *
 * The audio format can be changed at run-time. This function configures the sample rate and audio data
 * format to be transferred.
 *
 * @param base ESAI base pointer.
 * @param handle ESAI handle pointer.
 * @param format Pointer to ESAI audio data format structure.
 * @param hckClockHz HCK clock frequency in Hz.
 * @param hckSourceClockHz HCK clock source frequency in Hz.
 * @return Status of this function. Return value is one of status_t.
 */
status_t ESAI_TransferRxSetFormat(
    ESAI_Type *base, esai_handle_t *handle, esai_format_t *format, uint32_t hckClockHz, uint32_t hckSourceClockHz);

/*!
 * @brief Performs an interrupt non-blocking send transfer on ESAI.
 *
 * @note This API returns immediately after the transfer initiates.
 * Call the ESAI_TxGetTransferStatusIRQ to poll the transfer status and check whether
 * the transfer is finished. If the return status is not kStatus_ESAI_Busy, the transfer
 * is finished.
 *
 * @param base ESAI base pointer
 * @param handle pointer to esai_handle_t structure which stores the transfer state
 * @param xfer pointer to esai_transfer_t structure
 * @retval kStatus_Success Successfully started the data receive.
 * @retval kStatus_ESAI_TxBusy Previous receive still not finished.
 * @retval kStatus_InvalidArgument The input parameter is invalid.
 */
status_t ESAI_TransferSendNonBlocking(ESAI_Type *base, esai_handle_t *handle, esai_transfer_t *xfer);

/*!
 * @brief Performs an interrupt non-blocking receive transfer on ESAI.
 *
 * @note This API returns immediately after the transfer initiates.
 * Call the ESAI_RxGetTransferStatusIRQ to poll the transfer status and check whether
 * the transfer is finished. If the return status is not kStatus_ESAI_Busy, the transfer
 * is finished.
 *
 * @param base ESAI base pointer
 * @param handle pointer to esai_handle_t structure which stores the transfer state
 * @param xfer pointer to esai_transfer_t structure
 * @retval kStatus_Success Successfully started the data receive.
 * @retval kStatus_ESAI_RxBusy Previous receive still not finished.
 * @retval kStatus_InvalidArgument The input parameter is invalid.
 */
status_t ESAI_TransferReceiveNonBlocking(ESAI_Type *base, esai_handle_t *handle, esai_transfer_t *xfer);

/*!
 * @brief Gets a set byte count.
 *
 * @param base ESAI base pointer.
 * @param handle pointer to esai_handle_t structure which stores the transfer state.
 * @param count Bytes count sent.
 * @retval kStatus_Success Succeed get the transfer count.
 * @retval kStatus_NoTransferInProgress There is not a non-blocking transaction currently in progress.
 */
status_t ESAI_TransferGetSendCount(ESAI_Type *base, esai_handle_t *handle, size_t *count);

/*!
 * @brief Gets a received byte count.
 *
 * @param base ESAI base pointer.
 * @param handle pointer to esai_handle_t structure which stores the transfer state.
 * @param count Bytes count received.
 * @retval kStatus_Success Succeed get the transfer count.
 * @retval kStatus_NoTransferInProgress There is not a non-blocking transaction currently in progress.
 */
status_t ESAI_TransferGetReceiveCount(ESAI_Type *base, esai_handle_t *handle, size_t *count);

/*!
 * @brief Aborts the current send.
 *
 * @note This API can be called any time when an interrupt non-blocking transfer initiates
 * to abort the transfer early.
 *
 * @param base ESAI base pointer.
 * @param handle pointer to esai_handle_t structure which stores the transfer state.
 */
void ESAI_TransferAbortSend(ESAI_Type *base, esai_handle_t *handle);

/*!
 * @brief Aborts the current IRQ receive.
 *
 * @note This API can be called any time when an interrupt non-blocking transfer initiates
 * to abort the transfer early.
 *
 * @param base ESAI base pointer
 * @param handle pointer to esai_handle_t structure which stores the transfer state.
 */
void ESAI_TransferAbortReceive(ESAI_Type *base, esai_handle_t *handle);

/*!
 * @brief Tx interrupt handler.
 *
 * @param base ESAI base pointer.
 * @param handle pointer to esai_handle_t structure.
 */
void ESAI_TransferTxHandleIRQ(ESAI_Type *base, esai_handle_t *handle);

/*!
 * @brief Tx interrupt handler.
 *
 * @param base ESAI base pointer.
 * @param handle pointer to esai_handle_t structure.
 */
void ESAI_TransferRxHandleIRQ(ESAI_Type *base, esai_handle_t *handle);

/*! @} */

#if defined(__cplusplus)
}
#endif /*_cplusplus*/

/*! @} */

#endif /* _FSL_ESAI_H_ */