/*
 * Copyright 2019-2021 NXP
 * All rights reserved.
 *
 * SPDX-License-Identifier: BSD-3-Clause
 */

#ifndef FSL_ASRC_H_
#define FSL_ASRC_H_

#include "fsl_common.h"

/*!
 * @addtogroup asrc_driver
 * @{
 */

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

/*! @name Driver version */
/*! @{ */
#define FSL_ASRC_DRIVER_VERSION (MAKE_VERSION(2, 0, 6)) /*!< Version 2.0.6 */
/*! @} */

/*! @brief ASRC fifo depth */
#define FSL_ASRC_INPUT_FIFO_DEPTH  (128U)
#define FSL_ASRC_OUTPUT_FIFO_DEPTH (64U)
/*! @brief ASRC support maximum channel number of context */
#define ASRC_SUPPORT_MAXIMUM_CONTEXT_PROCESSOR_NUMBER 4U

/*! @brief ASRC return status, _asrc_status*/
enum
{
    kStatus_ASRCIdle                     = MAKE_STATUS(kStatusGroup_ASRC, 0),  /*!< ASRC  is idle. */
    kStatus_ASRCBusy                     = MAKE_STATUS(kStatusGroup_ASRC, 1),  /*!< ASRC  is busy. */
    kStatus_ASRCInvalidArgument          = MAKE_STATUS(kStatusGroup_ASRC, 2),  /*!< ASRC invalid argument. */
    kStatus_ASRCConfigureFailed          = MAKE_STATUS(kStatusGroup_ASRC, 3),  /*!< ASRC configure failed */
    kStatus_ASRCConvertError             = MAKE_STATUS(kStatusGroup_ASRC, 4),  /*!< ASRC convert error failed */
    kStatus_ASRCNotSupport               = MAKE_STATUS(kStatusGroup_ASRC, 5),  /*!< ASRC not support */
    kStatus_ASRCQueueFull                = MAKE_STATUS(kStatusGroup_ASRC, 6),  /*!< ASRC queue full */
    kStatus_ASRCQueueIdle                = MAKE_STATUS(kStatusGroup_ASRC, 7),  /*!< ASRC quue idle */
    kStatus_ASRCLoadFirmwareFailed       = MAKE_STATUS(kStatusGroup_ASRC, 8),  /*!< ASRC load firmware failed*/
    kStatus_ASRCResamplerConfigureFailed = MAKE_STATUS(kStatusGroup_ASRC, 9),  /*!< ASRC resampler configured failed */
    kStatus_ASRCPrefilterConfigureFailed = MAKE_STATUS(kStatusGroup_ASRC, 10), /*!< ASRC prefilter configured failed */
};

/*! @brief asrc context id */
typedef enum _asrc_context
{
    kASRC_Context0 = 0, /*!< Context 0 value */
    kASRC_Context1 = 1, /*!< Context 1 value */
    kASRC_Context2 = 2, /*!< Context 2 value */
    kASRC_Context3 = 3, /*!< Context 3 value */
} asrc_context_t;

/*! @brief The ASRC interrupt enable flag, _asrc_interrupt_mask*/
enum
{
    kASRC_Context0InputFifoOverflow = 1U,       /*!< context 0 input fifo overflow */
    kASRC_Context1InputFifoOverflow = 1U << 1U, /*!< context 1 input fifo overflow */
    kASRC_Context2InputFifoOverflow = 1U << 2U, /*!< context 2 input fifo overflow */
    kASRC_Context3InputFifoOverflow = 1U << 3U, /*!< context 3 input fifo overflow */

    kASRC_Context0OutFifoReadEmpty = 1U << 4U, /*!< context 0 out fifo read empty */
    kASRC_Context1OutFifoReadEmpty = 1U << 5U, /*!< context 1 out fifo read empty */
    kASRC_Context2OutFifoReadEmpty = 1U << 6U, /*!< context 2 out fifo read empty */
    kASRC_Context3OutFifoReadEmpty = 1U << 7U, /*!< context 3 out fifo read empty */

    kASRC_Context0RunStopDone       = 1U << 8U,  /*!< context 0 run stop done interrupt */
    kASRC_Context1RunStopDone       = 1U << 9U,  /*!< context 1 run stop done interrupt */
    kASRC_Context2RunStopDone       = 1U << 10U, /*!< context 2 run stop done interrupt */
    kASRC_Context3RunStopDone       = 1U << 11U, /*!< context 3 run stop done interrupt */
    kASRC_ContextAllInterruptStatus = 0xFFFU,    /*!< all the context interrupt status */
};

/*! @brief ASRC fifo status, _asrc_fifo_status*/
enum
{
    kASRC_FifoStatusInputFifoWatermarkFlag =
        ASRC_SAMPLE_FIFO_STATUS_INFIFO_WTMK_MASK, /*!< input water mark flag raised */
    kASRC_FifoStatusOutputFifoWatermarkFlag =
        ASRC_SAMPLE_FIFO_STATUS_OUTFIFO_WTMK_MASK, /*!< output water mark flag raised */
};

/*! @brief arsc data endianness */
typedef enum _asrc_data_endianness
{
    kASRC_DataEndianLittle = 0U, /*!< context data little endian */
    kASRC_DataEndianBig    = 1U, /*!< context data big endian */
} asrc_data_endianness_t;

/*! @brief data width */
typedef enum _asrc_data_width
{
    kASRC_DataWidth32Bit = 3U, /*!< data width 32bit */
    kASRC_DataWidth24Bit = 2U, /*!< data width 24bit */
    kASRC_DataWidth20Bit = 1U, /*!< data width 20bit */
    kASRC_DataWidth16Bit = 0U, /*!< data width 16bit */
} asrc_data_width_t;

/*! @brief data type */
typedef enum _asrc_data_type
{
    kASRC_DataTypeInteger = 0U, /*!< data type int */
    kASRC_DataTypeFloat   = 1U, /*!< data type float, single precision floating point format */
} asrc_data_type_t;

/*! @brief sign extension */
typedef enum _asrc_data_sign
{
    kASRC_DataSigned   = 0U, /*!< input data is signed */
    kASRC_DataUnsigned = 1U, /*!< input data is unsinged */
} asrc_data_sign_t;

/*! @brief  asrc prefilter and resampler sample buffer init mode */
typedef enum _asrc_sampleBuffer_init_mode
{
    kASRC_SampleBufferNoPreFillOnInit = 0U, /*!< do not pre-fill */
    kASRC_SampleBufferFillFirstSampleOnInit =
        1U, /*!< replicate the first sample to fill the right half of the sample buffer */
    kASRC_SampleBufferFillZeroOnInit = 2U, /*!< zero fill the right half og the sample buffer */
} asrc_sampleBuffer_init_mode_t;

/*! @brief  asrc prefilter and resampler sample buffer stop mode */
typedef enum _asrc_sampleBuffer_stop_mode
{
    kASRC_SampleBufferFillLastSampleOnStop =
        0U,                                /*!< replicate the last sample to fill the left half of the sample buffer */
    kASRC_SampleBufferFillZeroOnStop = 1U, /*!< zero fill the left half of the sample buffer */
} asrc_sampleBuffer_stop_mode_t;

/*! @brief ASRC prefilter stage1 result format */
typedef enum _asrc_prefilter_stage1_result
{
    kASRC_PrefilterStage1ResultInt   = 0U, /*!< prefilter stage1 results are stored in 32 bit int format */
    kASRC_PrefilterStage1ResultFloat = 1U, /*!< prefilter stage1 results are stored in 32 bit float format */
} asrc_prefilter_stage1_result_t;

/*! @brief ASRC resampler taps */
typedef enum _asrc_resampler_taps
{
    kASRC_ResamplerTaps_32  = 32U,  /*!< resampler taps 32 */
    kASRC_ResamplerTaps_64  = 64U,  /*!< resampler taps 64 */
    kASRC_ResamplerTaps_128 = 128U, /*!< resampler taps 128 */
} asrc_resampler_taps_t;

/*! @brief ASRC support sample rate, _asrc_sample_rate */
enum
{
    kASRC_SampleRate_8000   = 8000,   /*!< 8K sample rate */
    kASRC_SampleRate_11025  = 11025,  /*!< 11025 sample rate */
    kASRC_SampleRate_12000  = 12000,  /*!< 12K sample rate */
    kASRC_SampleRate_16000  = 16000,  /*!< 16K sample rate */
    kASRC_SampleRate_22050  = 22050,  /*!< 22.05K sample rate */
    kASRC_SampleRate_24000  = 24000,  /*!< 24K sample rate */
    kASRC_SampleRate_32000  = 32000,  /*!< 32K sample rate */
    kASRC_SampleRate_44100  = 44100,  /*!< 44.1K sample rate */
    kASRC_SampleRate_48000  = 48000,  /*!< 48K sample rate */
    kASRC_SampleRate_64000  = 64000,  /*!< 64K sample rate */
    kASRC_SampleRate_88200  = 88200,  /*!< 88.2K sample rate */
    kASRC_SampleRate_96000  = 96000,  /*!< 96K sample rate */
    kASRC_SampleRate_128000 = 128000, /*!< 128K sample rate */
    kASRC_SampleRate_176400 = 176400, /*!< 176K sample rate */
    kASRC_SampleRate_192000 = 192000, /*!< 256K sample rate */
    kASRC_SampleRate_256000 = 256000, /*!< 256K sample rate */
    kASRC_SampleRate_352800 = 352800, /*!< 352.8K sample rate */
    kASRC_SampleRate_384000 = 384000, /*!< 384K sample rate */
    kASRC_SampleRate_768000 = 768000, /*!< 768K sample rate */
};

/*! @brief asrc context data format */
typedef struct _asrc_data_format
{
    uint8_t dataPosition;                  /*!< context input data sample position */
    asrc_data_endianness_t dataEndianness; /*!< context input data endianness */
    asrc_data_width_t dataWidth;           /*!< context input data width */
    asrc_data_type_t dataType;             /*!< context input data type */
    asrc_data_sign_t dataSign;             /*!< context input data signed or unsigned */
} asrc_data_format_t;

/*! @brief asrc context access control
 * The ASRC provides interleaving support in hardware to ensure that a variety of sample source can be internally
 * combined tp confir with this format. The interleave patter is controlled using 3 register fields: GROUP_LENGTH,
 * ACCESS_LENGTH, ITERATIONIS. This is intended to support hardware configurations which distribute a single context
 * across samples from multiple audio sources. Take a example as below: accessGroupLen = 6, the sample group length is 6
 * samples accessIterations = 2, the 2 sequential ACCESS_LENGTH read from single source accessLen = 2, the 2 samples
 * fetch from one source.
 */
typedef struct _asrc_access_ctrl
{
    uint8_t accessIterations; /*!< number of sequential fetches per source */
    uint8_t accessGroupLen;   /*!< number of channels in a context */
    uint8_t accessLen;        /*!< number of channels per source1 */
} asrc_access_ctrl_t;

/*! @brief asrc context input configuration */
typedef struct _asrc_context_input_config
{
    uint32_t sampleRate;           /*!< input audio data sample rate */
    uint8_t watermark;             /*!< input water mark per samples */
    asrc_access_ctrl_t accessCtrl; /*!< input access control */
    asrc_data_format_t dataFormat; /*!< input data format */
} asrc_context_input_config_t;

/*! @brief asrc context output configuration */
typedef struct _asrc_context_output_config
{
    uint32_t sampleRate;           /*!< output audio data sample rate */
    uint8_t watermark;             /*!< output water mark per samples */
    asrc_access_ctrl_t accessCtrl; /*!< output access control */
    asrc_data_format_t dataFormat; /*!< output data format */
    bool enableDither;   /*!< output path contains a TPDF dither function. The dither function support all fixed output
                            modes(16, 20, 24, 32bits)   dither is not supported in 32bit floating point output mode */
    bool enableIEC60958; /*!< output IEC60958 bit field insertion enable */
} asrc_context_output_config_t;

/*! @brief asrc context prefilter configuration */
typedef struct _asrc_context_prefilter_config
{
    asrc_sampleBuffer_init_mode_t initMode;      /*!< prefilter initial mode */
    asrc_sampleBuffer_stop_mode_t stopMode;      /*!< prefilter stop mode */
    asrc_prefilter_stage1_result_t stage1Result; /*!< stage1 data store format */
    /*
     * applciation can untouch below configuration by set filterCoeffAddress to NULL , driver will load it from the
     * driver firmware table, otherwise driver will use the value directly.
     */
    uint32_t filterSt1Taps;             /*!< prefilter stage1 taps */
    uint32_t filterSt2Taps;             /*!< prefilter stage2 taps */
    uint32_t filterSt1Exp;              /*!< prefilter stage1 expansion factor */
    const uint32_t *filterCoeffAddress; /*!< prefilter coeff address */
} asrc_context_prefilter_config_t;

/*! @brief asrc context resampler configuration */
typedef struct _asrc_context_resampler_config
{
    asrc_sampleBuffer_init_mode_t initMode; /*!< initial mode */
    asrc_sampleBuffer_stop_mode_t stopMode; /*!< resampler stop mode */
    asrc_resampler_taps_t tap;              /*!< resampleer taps */
    /*
     * applciation can untouch below configuration by set filterCoeffAddress to NULL , driver will load it from the
     * driver firmware table, otherwise driver will use the value directly.
     */
    uint32_t filterPhases;              /*!< interpolation phases */
    uint64_t filterCenterTap;           /*!< interpolation center tap */
    const uint32_t *filterCoeffAddress; /*!< interpolation coeff address */
} asrc_context_resampler_config_t;

/*! @brief asrc context configuration */
typedef struct _asrc_context_config
{
    uint8_t contextChannelNums;                       /*!< context channel numbers */
    asrc_context_input_config_t contextInput;         /*!< context input configuration */
    asrc_context_output_config_t contextOutput;       /*!< context output configuration */
    asrc_context_prefilter_config_t contextPrefilter; /*!< context pre filter configuration */
    asrc_context_resampler_config_t contextResampler; /*!< context resampler configuration */
} asrc_context_config_t;

/*! @brief ASRC transfer */
typedef struct _asrc_transfer
{
    uint32_t *inDataAddr;  /*!< address of audio data to be converted */
    uint32_t inDataSize;   /*!< size of the audio data */
    uint32_t *outDataAddr; /*!< address of audio data that is been converted */
    uint32_t outDataSize;  /*!< size of the audio data */
} asrc_transfer_t;
/*******************************************************************************
 * API
 ******************************************************************************/

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

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

/*!
 * @brief Get instance number of the ASRC peripheral.
 *
 * @param base ASRC base pointer.
 */
uint32_t ASRC_GetInstance(ASRC_Type *base);

/*!
 * brief Initializes the asrc peripheral.
 *
 * This API gates the asrc clock. The asrc module can't operate unless ASRC_Init is called to enable the clock.
 *
 * param base asrc base pointer.
 */
void ASRC_Init(ASRC_Type *base);

/*!
 * @brief De-initializes the ASRC peripheral.
 *
 * This API gates the ASRC clock and disable ASRC module. The ASRC module can't operate unless ASRC_Init
 *
 * @param base ASRC base pointer.
 */
void ASRC_Deinit(ASRC_Type *base);

/*!
 * @brief ASRC get context default configuration.
 *
 * @param config ASRC context configuration pointer.
 * @param channels input audio data channel numbers.
 * @param inSampleRate input sample rate.
 * @param outSampleRate output sample rate.
 */
void ASRC_GetContextDefaultConfig(asrc_context_config_t *config,
                                  uint32_t channels,
                                  uint32_t inSampleRate,
                                  uint32_t outSampleRate);

/*!
 * @brief ASRC configure context.
 *
 * @param base ASRC base pointer.
 * @param context index of asrc context, reference asrc_context_t.
 * @param config ASRC context configuration pointer.
 * @retval kStatus_InvalidArgument invalid parameters.
 *        kStatus_ASRCConfigureFailed context configure failed.
 *        kStatus_Success context configure success.
 */
status_t ASRC_SetContextConfig(ASRC_Type *base, asrc_context_t context, asrc_context_config_t *config);

/*!
 * @brief ASRC configure context output.
 *
 * @param base ASRC base pointer.
 * @param context index of asrc context, reference asrc_context_t.
 * @param config ASRC context output configuration pointer.
 */
status_t ASRC_SetContextOutputConfig(ASRC_Type *base, asrc_context_t context, asrc_context_output_config_t *config);

/*!
 * @brief ASRC configure context input.
 *
 * @param base ASRC base pointer.
 * @param context index of asrc context, reference asrc_context_t.
 * @param config ASRC context input configuration pointer.
 */
status_t ASRC_SetContextInputConfig(ASRC_Type *base, asrc_context_t context, asrc_context_input_config_t *config);

/*!
 * @brief ASRC context enable run.
 * All control fileds associated with a context must be stable prior to setting context run enable.
 *
 * @param base ASRC base pointer.
 * @param context ASRC context index.
 * @param enable true is enable, inform the datapath begin processing sample data for the context.
 *               false is disable, data processing will halt immediately.
 */
static inline void ASRC_EnableContextRun(ASRC_Type *base, asrc_context_t context, bool enable)
{
    if (enable)
    {
        base->CTX_CTRL[context] |= ASRC_CTX_CTRL_RUN_EN_MASK;
    }
    else
    {
        base->CTX_CTRL[context] &= ~ASRC_CTX_CTRL_RUN_EN_MASK;
    }
}

/*!
 * @brief ASRC context enable run stop.
 * This function used to flush the ASRC pipeline and completely end processing for a context.
 *
 * @param base ASRC base pointer.
 * @param context ASRC context index.
 * @param enable true is enable, false is disable.
 */
static inline void ASRC_EnableContextRunStop(ASRC_Type *base, asrc_context_t context, bool enable)
{
    if (enable)
    {
        base->CTX_CTRL[context] |= ASRC_CTX_CTRL_RUN_STOP_MASK;
    }
    else
    {
        base->CTX_CTRL[context] &= ~ASRC_CTX_CTRL_RUN_STOP_MASK;
    }
}

/*!
 * @brief ASRC context input DMA request enable.
 *
 * @param base ASRC base pointer.
 * @param context ASRC context index.
 * @param enable true is enable, false is disable.
 */
static inline void ASRC_EnableContextInDMA(ASRC_Type *base, asrc_context_t context, bool enable)
{
    if (enable)
    {
        base->CTX_CTRL[context] |= ASRC_CTX_CTRL_FWMDE_MASK;
    }
    else
    {
        base->CTX_CTRL[context] &= ~ASRC_CTX_CTRL_FWMDE_MASK;
    }
}

/*!
 * @brief ASRC context output DMA request enable.
 *
 * @param base ASRC base pointer.
 * @param context ASRC context index.
 * @param enable true is enable, false is disable.
 */
static inline void ASRC_EnableContextOutDMA(ASRC_Type *base, asrc_context_t context, bool enable)
{
    if (enable)
    {
        base->CTX_OUT_CTRL[context] |= ASRC_CTX_OUT_CTRL_FWMDE_MASK;
    }
    else
    {
        base->CTX_OUT_CTRL[context] &= ~ASRC_CTX_OUT_CTRL_FWMDE_MASK;
    }
}

/*!
 * @brief ASRC prefilter bypass mode
 * This function enable or disable the ASRC prefilter bypass mode.
 *
 * @param base ASRC peripheral base address.
 * @param context context processor number.
 * @param bypass true is bypass, false is normal mode.
 */
static inline void ASRC_EnablePreFilterBypass(ASRC_Type *base, asrc_context_t context, bool bypass)
{
    if (bypass)
    {
        base->CTX_CTRL_EXT1[context] |= ASRC_CTX_CTRL_EXT1_PF_BYPASS_MODE_MASK;
        base->CTX_CTRL_EXT1[context] &= ~ASRC_CTX_CTRL_EXT1_PF_EXPANSION_FACTOR_MASK;
        base->CTX_CTRL_EXT2[context] &= ~ASRC_CTX_CTRL_EXT2_ST1_NUM_TAPS_MASK;
    }
    else
    {
        base->CTX_CTRL_EXT1[context] &= ~ASRC_CTX_CTRL_EXT1_PF_BYPASS_MODE_MASK;
    }
}

/*!
 * @brief ASRC resampler bypass mode
 * This function enable or disable the ASRC resampler bypass mode.
 *
 * @param base ASRC peripheral base address.
 * @param context context processor number.
 * @param bypass true is bypass, false is normal mode.
 */
static inline void ASRC_EnableResamplerBypass(ASRC_Type *base, asrc_context_t context, bool bypass)
{
    if (bypass)
    {
        base->CTX_CTRL_EXT1[context] |= ASRC_CTX_CTRL_EXT1_RS_BYPASS_MODE_MASK;
    }
    else
    {
        base->CTX_CTRL_EXT1[context] &= ~ASRC_CTX_CTRL_EXT1_RS_BYPASS_MODE_MASK;
    }
}

/*!
 * @brief ASRC set context channel number.
 * Note: The maximum channel number in one context can not exceed 32.
 *
 * @param base ASRC peripheral base address.
 * @param context context  number.
 * @param channels channel number, should <= 32.
 */
static inline void ASRC_SetContextChannelNumber(ASRC_Type *base, asrc_context_t context, uint32_t channels)
{
    base->CTX_CTRL[context] &= ~ASRC_CTX_CTRL_NUM_CH_EN_MASK;
    base->CTX_CTRL[context] |= ASRC_CTX_CTRL_NUM_CH_EN(channels - 1U);
}

/*!
 * @brief ASRC get output sample count.
 *
 * @param inSampleRate output sample rate.
 * @param inSamplesSize input sample rate.
 * @param inWidth input samples buffer size, the size of buffer should be converted to align with 4 byte .
 * @param outSampleRate input sample width.
 * @param outWidth Output width.
 * @retval output samples size.
 */
uint32_t ASRC_GetContextOutSampleSize(
    uint32_t inSampleRate, uint32_t inSamplesSize, uint32_t inWidth, uint32_t outSampleRate, uint32_t outWidth);

/*! @} */

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

/*!
 * @brief ASRC interrupt enable
 * This function enable the ASRC interrupt with the provided mask.
 *
 * @param base ASRC peripheral base address.
 * @param mask The interrupts to enable. Logical OR of _asrc_interrupt_mask.
 */
static inline void ASRC_EnableInterrupt(ASRC_Type *base, uint32_t mask)
{
    base->IRQ_CTRL &= ~mask;
}

/*!
 * @brief ASRC interrupt disable
 * This function disable the ASRC interrupt with the provided mask.
 *
 * @param base ASRC peripheral base address.
 * @param mask The interrupts to disable. Logical OR of _asrc_interrupt_mask.
 */
static inline void ASRC_DisableInterrupt(ASRC_Type *base, uint32_t mask)
{
    base->IRQ_CTRL |= mask;
}
/*! @} */

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

/*!
 * @brief Gets the ASRC interrupt status flag state.
 *
 * @param base ASRC base pointer
 * @return ASRC Tx status flag value. Use the Status Mask to get the status value needed.
 */
static inline uint32_t ASRC_GetInterruptStatus(ASRC_Type *base)
{
    return base->IRQ_FLAGS;
}

/*!
 * @brief clear the ASRC interrupt status flag state.
 *
 * @param base ASRC base pointer
 * @param status status flag to be cleared.
 */
static inline void ASRC_ClearInterruptStatus(ASRC_Type *base, uint32_t status)
{
    base->IRQ_FLAGS |= status;
}

/*!
 * @brief Gets the ASRC fifo status flag.
 *
 * @param base ASRC base pointer
 * @param context context id
 */
static inline uint32_t ASRC_GetFifoStatus(ASRC_Type *base, asrc_context_t context)
{
    return (uint32_t)(base->SAMPLE_FIFO_STATUS[context] &
                      (ASRC_SAMPLE_FIFO_STATUS_OUTFIFO_WTMK_MASK | ASRC_SAMPLE_FIFO_STATUS_INFIFO_WTMK_MASK));
}

/*! @} */

/*!
 * @name fifo Operations
 * @{
 */
/*!
 * @brief write the ASRC context fifo.
 *
 * @param base ASRC base pointer.
 * @param context context id.
 * @param data data to write.
 */
static inline void ASRC_WriteContextFifo(ASRC_Type *base, asrc_context_t context, uint32_t data)
{
    base->WRFIFO[context] = data;
}

/*!
 * @brief read the ASRC context fifo.
 *
 * @param base ASRC base pointer.
 * @param context context id.
 * @retval read data.
 */
static inline uint32_t ASRC_ReadContextFifo(ASRC_Type *base, asrc_context_t context)
{
    return base->RDFIFO[context];
}

/*!
 * @brief Get ASRC write fifo address.
 *
 * @param base ASRC base pointer.
 * @param context context id.
 * @retval write fifo address.
 */
static inline uint32_t ASRC_GetWriteContextFifoAddr(ASRC_Type *base, asrc_context_t context)
{
    return (uint32_t)&base->WRFIFO[context];
}

/*!
 * @brief Get the ASRC read context fifo address.
 *
 * @param base ASRC base pointer.
 * @param context context id.
 * @retval read fifo address.
 */
static inline uint32_t ASRC_GetReadContextFifoAddr(ASRC_Type *base, asrc_context_t context)
{
    return (uint32_t)&base->RDFIFO[context];
}

/*!
 * @brief Get the ASRC read fifo remained samples.
 * Since the DMA request will be triggered only when the sample group in read fifo is bigger then the watermark, so when
 * the data size cannot be divisible by the (watermark + 1), then part of sample will left in read fifo, application
 * should call this api to get the left samples.
 *
 * @param base ASRC base pointer.
 * @param context context id.
 * @param outAddr address to receive remained sample in read fifo.
 * @param outWidth output data width.
 * @param sampleCount specify the read sample count.
 * @retval sample counts actual read from output fifo.
 */
uint32_t ASRC_ReadFIFORemainedSample(
    ASRC_Type *base, asrc_context_t context, uint32_t *outAddr, uint32_t outWidth, uint32_t sampleCount);

/*! @} */

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

/*!
 * @brief ASRC blocking convert audio sample rate.
 * This function depends on the configuration of input and output, so it should be called after the
 * ASRC_SetContextConfig. The data format it supports:
 * 1.16bit 16bit per sample in input buffer, input buffer size
 * should be calculate as: samples 2U output buffer size can be calculated by call function
 * ASRC_GetContextOutSampleSize, the parameter outWidth should be 2
 * 2.20bit 24bit per sample in input buffer, input buffer size should be calculate as: samples 3U output buffer size can
 * be calculated by call function ASRC_GetContextOutSampleSize, the outWidth should be 3. 3.24bit 24bit per sample in
 * input buffer, input buffer size should be calculate as: samples * 3U output buffer size can be calculated by call
 * function ASRC_GetContextOutSampleSize, the outWidth should be 3. 4.32bit 32bit per sample in input buffer, input
 * buffer size should be calculate as: samples * 4U output buffer size can be calculated by call function
 * ASRC_GetContextOutSampleSize, the outWidth should be 4.
 *
 * @param base ASRC base pointer.
 * @param context context id.
 * @param xfer .xfer configuration.
 * @retval kStatus_Success.
 */
status_t ASRC_TransferBlocking(ASRC_Type *base, asrc_context_t context, asrc_transfer_t *xfer);

/*! @} */

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

/*! @} */

#endif /* FSL_ASRC_H_ */
