fsl_asrc.h

/*
 * 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"
 
/*******************************************************************************
 * Definitions
 ******************************************************************************/
 
#define FSL_ASRC_DRIVER_VERSION (MAKE_VERSION(2, 1, 2)) 
 
#ifndef ASRC_XFER_QUEUE_SIZE
#define ASRC_XFER_QUEUE_SIZE (4U)
#endif
#define FSL_ASRC_CHANNEL_PAIR_COUNT (4U)
#define FSL_ASRC_CHANNEL_PAIR_FIFO_DEPTH (64U)
 
#define ASRC_ASRCTR_AT_MASK(index)    ((uint32_t)1U << (ASRC_ASRCTR_ATSA_SHIFT + (uint32_t)(index)))
#define ASRC_ASRCTR_RATIO_MASK(index) ((uint32_t)3U << (ASRC_ASRCTR_IDRA_SHIFT + (uint32_t)(index)*2U))
#define ASRC_ASRCTR_RATIO(ratio, index) \
    (((uint32_t)((uint32_t)(ratio) << (ASRC_ASRCTR_IDRA_SHIFT + (uint32_t)(index)*2U))) & ASRC_ASRCTR_RATIO_MASK(index))
#define ASRC_ASRIER_INPUT_INTERRUPT_MASK(index)     ((uint32_t)1U << (ASRC_ASRIER_ADIEA_SHIFT + (uint32_t)(index)))
#define ASRC_ASRIER_OUTPUTPUT_INTERRUPT_MASK(index) ((uint32_t)1U << (ASRC_ASRIER_ADOEA_SHIFT + (uint32_t)(index)))
#define ASRC_ASRCNCR_CHANNEL_COUNTER_MASK(index)    ((uint32_t)0xFU << (ASRC_ASRCNCR_ANCA_SHIFT + (uint32_t)(index)*4U))
#define ASRC_ASRCNCR_CHANNEL_COUNTER(counter, index)                                       \
    ((uint32_t)((uint32_t)(counter) << (ASRC_ASRCNCR_ANCA_SHIFT + (uint32_t)(index)*4U)) & \
     ASRC_ASRCNCR_CHANNEL_COUNTER_MASK(index))
#define ASRC_ASRCFG_PRE_MODE_MASK(index) ((uint32_t)3U << (ASRC_ASRCFG_PREMODA_SHIFT + (uint32_t)(index)*4U))
#define ASRC_ASRCFG_PRE_MODE(mode, index)                                                 \
    ((uint32_t)((uint32_t)(mode) << (ASRC_ASRCFG_PREMODA_SHIFT + (uint32_t)(index)*4U)) & \
     ASRC_ASRCFG_PRE_MODE_MASK(index))
#define ASRC_ASRCFG_POST_MODE_MASK(index) ((uint32_t)3U << (ASRC_ASRCFG_POSTMODA_SHIFT + (uint32_t)(index)*4U))
#define ASRC_ASRCFG_POST_MODE(mode, index)                                                 \
    ((uint32_t)((uint32_t)(mode) << (ASRC_ASRCFG_POSTMODA_SHIFT + (uint32_t)(index)*4U)) & \
     ASRC_ASRCFG_POST_MODE_MASK(index))
#define ASRC_ASRCFG_INIT_DONE_MASK(index)          ((uint32_t)1U << (ASRC_ASRCFG_INIRQA_SHIFT + (uint32_t)(index)))
#define ASRC_ASRCSR_INPUT_CLOCK_SOURCE_MASK(index) ((uint32_t)0xFU << (ASRC_ASRCSR_AICSA_SHIFT + (uint32_t)(index)*4U))
#define ASRC_ASRCSR_INPUT_CLOCK_SOURCE(source, index)                                     \
    ((uint32_t)((uint32_t)(source) << (ASRC_ASRCSR_AICSA_SHIFT + (uint32_t)(index)*4U)) & \
     ASRC_ASRCSR_INPUT_CLOCK_SOURCE_MASK(index))
#define ASRC_ASRCSR_OUTPUT_CLOCK_SOURCE_MASK(index) ((uint32_t)0xFU << (ASRC_ASRCSR_AOCSA_SHIFT + (uint32_t)(index)*4U))
#define ASRC_ASRCSR_OUTPUT_CLOCK_SOURCE(source, index)                                    \
    ((uint32_t)((uint32_t)(source) << (ASRC_ASRCSR_AOCSA_SHIFT + (uint32_t)(index)*4U)) & \
     ASRC_ASRCSR_OUTPUT_CLOCK_SOURCE_MASK(index))
 
#define ASRC_ASRCDR_INPUT_PRESCALER_MASK(index) \
    ((uint32_t)(index) < 2U ? ((uint32_t)7U << (ASRC_ASRCDR1_AICPA_SHIFT + (uint32_t)(index)*6U)) : 7U)
#define ASRC_ASRCDR_INPUT_PRESCALER(prescaler, index)                                                              \
    (((index) < 2U ? ((uint32_t)(prescaler) << (ASRC_ASRCDR1_AICPA_SHIFT + (uint32_t)(index)*6U)) : (prescaler)) & \
     ASRC_ASRCDR1_INPUT_PRESCALER_MASK(index))
#define ASRC_ASRCDR_INPUT_DIVIDER_MASK(index)                                                       \
    ((uint32_t)(index) < 2U ? ((uint32_t)7U << (ASRC_ASRCDR1_AICDA_SHIFT + (uint32_t)(index)*6U)) : \
                              (7U << ASRC_ASRCDR1_AICDA_SHIFT))
#define ASRC_ASRCDR_INPUT_DIVIDER(divider, index)                                                           \
    (((uint32_t)(index) < 2U ? ((uint32_t)(divider) << (ASRC_ASRCDR1_AICDA_SHIFT + (uint32_t)(index)*6U)) : \
                               ((uint32_t)(divider) << ASRC_ASRCDR1_AICDA_SHIFT)) &                         \
     ASRC_ASRCDR_INPUT_DIVIDER_MASK(index))
#define ASRC_ASRCDR_OUTPUT_PRESCALER_MASK(index) \
    ((uint32_t)(index) < 2U ? ((uint32_t)7U << (ASRC_ASRCDR1_AOCPA_SHIFT + (uint32_t)(index)*6U)) : (7U << 6U))
#define ASRC_ASRCDR_OUTPUT_PRESCALER(prescaler, index)                                                        \
    (((uint32_t)(index) < 2U ? ((uint32_t)(prescaler) << (ASRC_ASRCDR1_AOCPA_SHIFT + (uint32_t)(index)*6U)) : \
                               ((uint32_t)(prescaler) << 6U)) &                                               \
     ASRC_ASRCDR_OUTPUT_PRESCALER_MASK(index))
#define ASRC_ASRCDR_OUTPUT_DIVIDER_MASK(index) \
    ((uint32_t)(index) < 2U ? ((uint32_t)7U << (ASRC_ASRCDR1_AOCDA_SHIFT + (uint32_t)(index)*6U)) : (7UL << 9U))
#define ASRC_ASRCDR_OUTPUT_DIVIDER(divider, index)                                                          \
    (((uint32_t)(index) < 2U ? ((uint32_t)(divider) << (ASRC_ASRCDR1_AOCDA_SHIFT + (uint32_t)(index)*6U)) : \
                               ((uint32_t)(divider) << 9U)) &                                               \
     ASRC_ASRCDR_OUTPUT_DIVIDER_MASK(index))
 
#define ASCR_ASRCDR_OUTPUT_CLOCK_DIVIDER_PRESCALER(value, index)                                          \
    (((uint32_t)(index) < 2U ? ((uint32_t)(value) << (ASRC_ASRCDR1_AOCPA_SHIFT + (uint32_t)(index)*6U)) : \
                               ((uint32_t)(value) << 6U)))
#define ASCR_ASRCDR_INPUT_CLOCK_DIVIDER_PRESCALER(value, index) \
    (((uint32_t)(index) < 2U ? ((uint32_t)(value) << ((uint32_t)(index)*6U)) : ((uint32_t)(value))))
 
#define ASRC_IDEAL_RATIO_HIGH(base, index)    *(volatile uint32_t *)((uint32_t)(&(base)->ASRIDRHA) + (uint32_t)(index)*8U)
#define ASRC_IDEAL_RATIO_LOW(base, index)     *(volatile uint32_t *)((uint32_t)(&(base)->ASRIDRLA) + (uint32_t)(index)*8U)
#define ASRC_ASRMCR(base, index)              *(volatile uint32_t *)((uint32_t)(&(base)->ASRMCRA) + (uint32_t)(index)*8U)
#define ASRC_ASRMCR1(base, index)             *(volatile uint32_t *)((uint32_t)(&((base)->ASRMCR1[(index)])))
#define ASRC_ASRDI(base, index)               *(volatile uint32_t *)((uint32_t)(&(base)->ASRDIA) + (uint32_t)(index)*8U)
#define ASRC_ASRDO(base, index)               *(volatile uint32_t *)((uint32_t)(&(base)->ASRDOA) + (uint32_t)(index)*8U)
#define ASRC_ASRDI_ADDR(base, index)          (volatile uint32_t *)((uint32_t)(&(base)->ASRDIA) + (uint32_t)(index)*8U)
#define ASRC_ASRDO_ADDR(base, index)          (volatile uint32_t *)((uint32_t)(&(base)->ASRDOA) + (uint32_t)(index)*8U)
#define ASRC_ASRFST_ADDR(base, index)         (*(volatile uint32_t *)((uint32_t)(&(base)->ASRFSTA) + (uint32_t)(index)*8U))
#define ASRC_GET_CHANNEL_COUNTER(base, index) (((base)->ASRCNCR >> ((uint32_t)(index)*4U)) & 0xFU)
 
enum
{
    kStatus_ASRCIdle                       = MAKE_STATUS(kStatusGroup_ASRC, 0),  
    kStatus_ASRCInIdle                     = MAKE_STATUS(kStatusGroup_ASRC, 1),  
    kStatus_ASRCOutIdle                    = MAKE_STATUS(kStatusGroup_ASRC, 2),  
    kStatus_ASRCBusy                       = MAKE_STATUS(kStatusGroup_ASRC, 3),  
    kStatus_ASRCInvalidArgument            = MAKE_STATUS(kStatusGroup_ASRC, 4),  
    kStatus_ASRCClockConfigureFailed       = MAKE_STATUS(kStatusGroup_ASRC, 5),  
    kStatus_ASRCChannelPairConfigureFailed = MAKE_STATUS(kStatusGroup_ASRC, 6),  
    kStatus_ASRCConvertError               = MAKE_STATUS(kStatusGroup_ASRC, 7),  
    kStatus_ASRCNotSupport                 = MAKE_STATUS(kStatusGroup_ASRC, 8),  
    kStatus_ASRCQueueFull                  = MAKE_STATUS(kStatusGroup_ASRC, 9),  
    kStatus_ASRCOutQueueIdle               = MAKE_STATUS(kStatusGroup_ASRC, 10), 
    kStatus_ASRCInQueueIdle                = MAKE_STATUS(kStatusGroup_ASRC, 11), 
};
 
typedef enum _asrc_channel_pair
{
    kASRC_ChannelPairA = 0, 
    kASRC_ChannelPairB = 1, 
    kASRC_ChannelPairC = 2, 
} asrc_channel_pair_t;
 
enum
{
    kASRC_SampleRate_8000HZ   = 8000U,   
    kASRC_SampleRate_11025HZ  = 11025U,  
    kASRC_SampleRate_12000HZ  = 12000U,  
    kASRC_SampleRate_16000HZ  = 16000U,  
    kASRC_SampleRate_22050HZ  = 22050U,  
    kASRC_SampleRate_24000HZ  = 24000U,  
    kASRC_SampleRate_30000HZ  = 30000U,  
    kASRC_SampleRate_32000HZ  = 32000U,  
    kASRC_SampleRate_44100HZ  = 44100U,  
    kASRC_SampleRate_48000HZ  = 48000U,  
    kASRC_SampleRate_64000HZ  = 64000U,  
    kASRC_SampleRate_88200HZ  = 88200U,  
    kASRC_SampleRate_96000HZ  = 96000U,  
    kASRC_SampleRate_128000HZ = 128000U, 
    kASRC_SampleRate_176400HZ = 176400U, 
    kASRC_SampleRate_192000HZ = 192000U, 
};
 
enum
{
    kASRC_FPInWaitStateInterruptEnable = ASRC_ASRIER_AFPWE_MASK, 
    kASRC_OverLoadInterruptMask        = ASRC_ASRIER_AOLIE_MASK, 
    kASRC_DataOutputCInterruptMask     = ASRC_ASRIER_ADOEC_MASK, 
    kASRC_DataOutputBInterruptMask     = ASRC_ASRIER_ADOEB_MASK, 
    kASRC_DataOutputAInterruptMask     = ASRC_ASRIER_ADOEA_MASK, 
    kASRC_DataInputCInterruptMask      = ASRC_ASRIER_ADIEC_MASK, 
    kASRC_DataInputBInterruptMask      = ASRC_ASRIER_ADIEB_MASK, 
    kASRC_DataInputAInterruptMask      = ASRC_ASRIER_ADIEA_MASK, 
};
 
enum
{
    kASRC_StatusDSLCounterReady     = ASRC_ASRSTR_DSLCNT_MASK, 
    kASRC_StatusTaskQueueOverLoad   = ASRC_ASRSTR_ATQOL_MASK,  
    kASRC_StatusPairCOutputOverLoad = ASRC_ASRSTR_AOOLC_MASK,  
    kASRC_StatusPairBOutputOverLoad = ASRC_ASRSTR_AOOLB_MASK,  
    kASRC_StatusPairAOutputOverLoad = ASRC_ASRSTR_AOOLA_MASK,  
    kASRC_StatusPairCInputOverLoad  = ASRC_ASRSTR_AIOLC_MASK,  
    kASRC_StatusPairBInputOverLoad  = ASRC_ASRSTR_AIOLB_MASK,  
    kASRC_StatusPairAInputOverLoad  = ASRC_ASRSTR_AIOLA_MASK,  
    kASRC_StatusPairCOutputOverflow = ASRC_ASRSTR_AODOC_MASK,  
    kASRC_StatusPairBOutputOverflow = ASRC_ASRSTR_AODOB_MASK,  
    kASRC_StatusPairAOutputOverflow = ASRC_ASRSTR_AODOA_MASK,  
    kASRC_StatusPairCInputUnderflow = ASRC_ASRSTR_AIDUC_MASK,  
    kASRC_StatusPairBInputUnderflow = ASRC_ASRSTR_AIDUB_MASK,  
    kASRC_StatusPairAInputUnderflow = ASRC_ASRSTR_AIDUA_MASK,  
    kASRC_StatusFPInWaitState       = ASRC_ASRSTR_FPWT_MASK,   
    kASRC_StatusOverloadError       = ASRC_ASRSTR_AOLE_MASK,   
    kASRC_StatusInputError = kASRC_StatusPairCInputOverLoad | kASRC_StatusPairBInputOverLoad |
                             kASRC_StatusPairAInputOverLoad | kASRC_StatusPairCInputUnderflow |
                             kASRC_StatusPairBInputUnderflow |
                             kASRC_StatusPairAInputUnderflow, 
    kASRC_StatusOutputError = kASRC_StatusPairCOutputOverLoad | kASRC_StatusPairBOutputOverLoad |
                              kASRC_StatusPairAOutputOverLoad | kASRC_StatusPairCOutputOverflow |
                              kASRC_StatusPairBOutputOverflow |
                              kASRC_StatusPairAOutputOverflow, 
    kASRC_StatusPairCOutputReady = ASRC_ASRSTR_AODFC_MASK, 
    kASRC_StatusPairBOutputReady = ASRC_ASRSTR_AODFB_MASK, 
    kASRC_StatusPairAOutputReady = ASRC_ASRSTR_AODFA_MASK, 
    kASRC_StatusPairCInputReady  = ASRC_ASRSTR_AIDEC_MASK, 
    kASRC_StatusPairBInputReady  = ASRC_ASRSTR_AIDEB_MASK, 
    kASRC_StatusPairAInputReady  = ASRC_ASRSTR_AIDEA_MASK, 
    kASRC_StatusPairAInterrupt   = kASRC_StatusPairAInputReady | kASRC_StatusPairAOutputReady, 
    kASRC_StatusPairBInterrupt   = kASRC_StatusPairBInputReady | kASRC_StatusPairBOutputReady, 
    kASRC_StatusPairCInterrupt   = kASRC_StatusPairCInputReady | kASRC_StatusPairCOutputReady, 
};
 
enum
{
    kASRC_OutputFifoNearFull = ASRC_ASRFSTA_OAFA_MASK, 
    kASRC_InputFifoNearEmpty = ASRC_ASRFSTA_IAEA_MASK, 
};
 
typedef enum _asrc_ratio
{
    kASRC_RatioNotUsed = 0U, 
    kASRC_RatioUseInternalMeasured =
        2U, 
    kASRC_RatioUseIdealRatio =
        3U, 
} asrc_ratio_t;
 
typedef enum _asrc_audio_channel
{
    kASRC_ChannelsNumber1  = 1U,  
    kASRC_ChannelsNumber2  = 2U,  
    kASRC_ChannelsNumber3  = 3U,  
    kASRC_ChannelsNumber4  = 4U,  
    kASRC_ChannelsNumber5  = 5U,  
    kASRC_ChannelsNumber6  = 6U,  
    kASRC_ChannelsNumber7  = 7U,  
    kASRC_ChannelsNumber8  = 8U,  
    kASRC_ChannelsNumber9  = 9U,  
    kASRC_ChannelsNumber10 = 10U, 
} asrc_audio_channel_t;
 
typedef enum _asrc_data_width
{
    kASRC_DataWidth24Bit = 0U, 
    kASRC_DataWidth16Bit = 1U, 
    kASRC_DataWidth8Bit  = 2U, 
} asrc_data_width_t;
 
typedef enum _asrc_data_align
{
    kASRC_DataAlignMSB = 1U, 
    kASRC_DataAlignLSB = 0U, 
} asrc_data_align_t;
 
typedef enum _asrc_sign_extension
{
    kASRC_NoSignExtension = 0U, 
    kASRC_SignExtension   = 1U, 
} asrc_sign_extension_t;
 
typedef struct _asrc_channel_pair_config
{
    asrc_audio_channel_t audioDataChannels; 
    asrc_clock_source_t
        inClockSource;         
    uint32_t inSourceClock_Hz; 
    asrc_clock_source_t
        outClockSource;         
    uint32_t outSourceClock_Hz; 
    asrc_ratio_t sampleRateRatio; 
    asrc_data_width_t inDataWidth; 
    asrc_data_align_t inDataAlign; 
    asrc_data_width_t outDataWidth;         
    asrc_data_align_t outDataAlign;         
    asrc_sign_extension_t outSignExtension; 
    uint8_t outFifoThreshold; 
    uint8_t inFifoThreshold;  
    bool bufStallWhenFifoEmptyFull; 
} asrc_channel_pair_config_t;
 
typedef struct _asrc_transfer
{
    void *inData;       
    size_t inDataSize;  
    void *outData;      
    size_t outDataSize; 
} asrc_transfer_t;
 
typedef struct _asrc_handle asrc_handle_t;
 
typedef void (*asrc_transfer_callback_t)(ASRC_Type *base, asrc_handle_t *handle, status_t status, void *userData);
 
typedef struct _asrc_in_handle
{
    asrc_transfer_callback_t callback;            
    uint32_t sampleWidth;                         
    uint32_t sampleMask;                          
    uint32_t fifoThreshold;                       
    uint8_t *asrcQueue[ASRC_XFER_QUEUE_SIZE];     
    size_t transferSamples[ASRC_XFER_QUEUE_SIZE]; 
    volatile uint8_t queueUser;                   
    volatile uint8_t queueDriver;                 
} asrc_in_handle_t;
 
typedef struct _asrc_out_handle
{
    asrc_transfer_callback_t callback;            
    uint32_t sampleWidth;                         
    uint32_t fifoThreshold;                       
    uint8_t *asrcQueue[ASRC_XFER_QUEUE_SIZE];     
    size_t transferSamples[ASRC_XFER_QUEUE_SIZE]; 
    volatile uint8_t queueUser;                   
    volatile uint8_t queueDriver;                 
} asrc_out_handle_t;
 
struct _asrc_handle
{
    ASRC_Type *base; 
    uint32_t state; 
    void *userData; 
    asrc_audio_channel_t audioDataChannels; 
    asrc_channel_pair_t channelPair;        
    asrc_in_handle_t in;   
    asrc_out_handle_t out; 
};
/*******************************************************************************
 * API
 ******************************************************************************/
 
#if defined(__cplusplus)
extern "C" {
#endif /*_cplusplus*/
 
uint32_t ASRC_GetInstance(ASRC_Type *base);
 
void ASRC_Init(ASRC_Type *base, uint32_t asrcPeripheralClock_Hz);
 
void ASRC_Deinit(ASRC_Type *base);
 
void ASRC_SoftwareReset(ASRC_Type *base);
 
status_t ASRC_SetChannelPairConfig(ASRC_Type *base,
                                   asrc_channel_pair_t channelPair,
                                   asrc_channel_pair_config_t *config,
                                   uint32_t inputSampleRate,
                                   uint32_t outputSampleRate);
 
uint32_t ASRC_GetOutSamplesSize(ASRC_Type *base,
                                asrc_channel_pair_t channelPair,
                                uint32_t inSampleRate,
                                uint32_t outSampleRate,
                                uint32_t inSamplesize);
 
uint32_t ASRC_MapSamplesWidth(ASRC_Type *base, asrc_channel_pair_t channelPair, uint32_t *inWidth, uint32_t *outWidth);
 
uint32_t ASRC_GetRemainFifoSamples(ASRC_Type *base,
                                   asrc_channel_pair_t channelPair,
                                   uint32_t *buffer,
                                   uint32_t outSampleWidth,
                                   uint32_t remainSamples);
 
static inline void ASRC_ModuleEnable(ASRC_Type *base, bool enable)
{
    if (enable)
    {
        base->ASRCTR |= ASRC_ASRCTR_ASRCEN_MASK;
    }
    else
    {
        base->ASRCTR &= ~ASRC_ASRCTR_ASRCEN_MASK;
    }
}
 
static inline void ASRC_ChannelPairEnable(ASRC_Type *base, asrc_channel_pair_t channelPair, bool enable)
{
    if (enable)
    {
        base->ASRCTR |= 1UL << ((uint32_t)channelPair + 1U);
    }
    else
    {
        base->ASRCTR &= ~(1UL << ((uint32_t)channelPair + 1U));
    }
}
static inline void ASRC_EnableInterrupt(ASRC_Type *base, uint32_t mask)
{
    base->ASRIER |= mask;
}
 
static inline void ASRC_DisableInterrupt(ASRC_Type *base, uint32_t mask)
{
    base->ASRIER &= ~mask;
}
 
static inline uint32_t ASRC_GetStatus(ASRC_Type *base)
{
    return base->ASRSTR;
}
 
static inline bool ASRC_GetChannelPairInitialStatus(ASRC_Type *base, asrc_channel_pair_t channel)
{
    return ((base->ASRCFG >> ASRC_ASRCFG_INIRQA_SHIFT) & (1U << (uint32_t)channel)) == 0U ? false : true;
}
 
static inline uint32_t ASRC_GetChannelPairFifoStatus(ASRC_Type *base, asrc_channel_pair_t channelPair)
{
    return ASRC_ASRMCR(base, channelPair) & ((uint32_t)kASRC_OutputFifoNearFull | (uint32_t)kASRC_InputFifoNearEmpty);
}
 
static inline void ASRC_ChannelPairWriteData(ASRC_Type *base, asrc_channel_pair_t channelPair, uint32_t data)
{
    ASRC_ASRDI(base, channelPair) = data;
}
 
static inline uint32_t ASRC_ChannelPairReadData(ASRC_Type *base, asrc_channel_pair_t channelPair)
{
    return ASRC_ASRDO(base, channelPair);
}
 
static inline uint32_t ASRC_GetInputDataRegisterAddress(ASRC_Type *base, asrc_channel_pair_t channelPair)
{
    return (uint32_t)ASRC_ASRDI_ADDR(base, channelPair);
}
 
static inline uint32_t ASRC_GetOutputDataRegisterAddress(ASRC_Type *base, asrc_channel_pair_t channelPair)
{
    return (uint32_t)ASRC_ASRDO_ADDR(base, channelPair);
}
 
status_t ASRC_SetIdealRatioConfig(ASRC_Type *base,
                                  asrc_channel_pair_t channelPair,
                                  uint32_t inputSampleRate,
                                  uint32_t outputSampleRate);
 
status_t ASRC_TransferSetChannelPairConfig(ASRC_Type *base,
                                           asrc_handle_t *handle,
                                           asrc_channel_pair_config_t *config,
                                           uint32_t inputSampleRate,
                                           uint32_t outputSampleRate);
 
void ASRC_TransferCreateHandle(ASRC_Type *base,
                               asrc_handle_t *handle,
                               asrc_channel_pair_t channelPair,
                               asrc_transfer_callback_t inCallback,
                               asrc_transfer_callback_t outCallback,
                               void *userData);
 
status_t ASRC_TransferNonBlocking(ASRC_Type *base, asrc_handle_t *handle, asrc_transfer_t *xfer);
 
status_t ASRC_TransferBlocking(ASRC_Type *base, asrc_channel_pair_t channelPair, asrc_transfer_t *xfer);
 
status_t ASRC_TransferGetConvertedCount(ASRC_Type *base, asrc_handle_t *handle, size_t *count);
 
void ASRC_TransferAbortConvert(ASRC_Type *base, asrc_handle_t *handle);
 
void ASRC_TransferTerminateConvert(ASRC_Type *base, asrc_handle_t *handle);
 
void ASRC_TransferHandleIRQ(ASRC_Type *base, asrc_handle_t *handle);
 
#if defined(__cplusplus)
}
#endif /*_cplusplus*/
 
#endif /* _FSL_ASRC_H_ */