libs/rt-thread-official
libs
/
rt-thread-official
mirror of https://github.com/RT-Thread/rt-thread.git
4
0
Fork 0
Code Issues Releases Wiki Activity
rt-thread-official/bsp/imxrt/libraries/MIMXRT1170/MIMXRT1176/drivers/fsl_asrc.h

762 lines
32 KiB
C
Raw Blame History

/*
* 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, 1, 2)) /*!< Version 2.1.2 */
/*@}*/
#ifndef ASRC_XFER_QUEUE_SIZE
/*!@brief ASRC transfer queue size, user can refine it according to use case. */
#define ASRC_XFER_QUEUE_SIZE (4U)
#endif
/*!@brief ASRC channel pair count */
#define FSL_ASRC_CHANNEL_PAIR_COUNT (4U)
/*! @brief ASRC FIFO depth */
#define FSL_ASRC_CHANNEL_PAIR_FIFO_DEPTH (64U)
/*! @brief ASRC register access macro */
#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)
/*! @brief ASRC return status
* @anchor _asrc_status_t
*/
enum
{
kStatus_ASRCIdle = MAKE_STATUS(kStatusGroup_ASRC, 0), /*!< ASRC is idle. */
kStatus_ASRCInIdle = MAKE_STATUS(kStatusGroup_ASRC, 1), /*!< ASRC in is idle. */
kStatus_ASRCOutIdle = MAKE_STATUS(kStatusGroup_ASRC, 2), /*!< ASRC out is idle. */
kStatus_ASRCBusy = MAKE_STATUS(kStatusGroup_ASRC, 3), /*!< ASRC is busy. */
kStatus_ASRCInvalidArgument = MAKE_STATUS(kStatusGroup_ASRC, 4), /*!< ASRC invalid argument. */
kStatus_ASRCClockConfigureFailed = MAKE_STATUS(kStatusGroup_ASRC, 5), /*!< ASRC clock configure failed */
kStatus_ASRCChannelPairConfigureFailed = MAKE_STATUS(kStatusGroup_ASRC, 6), /*!< ASRC clock configure failed */
kStatus_ASRCConvertError = MAKE_STATUS(kStatusGroup_ASRC, 7), /*!< ASRC clock configure failed */
kStatus_ASRCNotSupport = MAKE_STATUS(kStatusGroup_ASRC, 8), /*!< ASRC not support */
kStatus_ASRCQueueFull = MAKE_STATUS(kStatusGroup_ASRC, 9), /*!< ASRC queue is full */
kStatus_ASRCOutQueueIdle = MAKE_STATUS(kStatusGroup_ASRC, 10), /*!< ASRC out queue is idle */
kStatus_ASRCInQueueIdle = MAKE_STATUS(kStatusGroup_ASRC, 11), /*!< ASRC in queue is idle */
};
/*! @brief ASRC channel pair mask */
typedef enum _asrc_channel_pair
{
kASRC_ChannelPairA = 0, /*!< channel pair A value */
kASRC_ChannelPairB = 1, /*!< channel pair B value */
kASRC_ChannelPairC = 2, /*!< channel pair C value */
} asrc_channel_pair_t;
/*! @brief ASRC support sample rate
* @anchor _asrc_sample_rate
*/
enum
{
kASRC_SampleRate_8000HZ = 8000U, /*!< asrc sample rate 8KHZ */
kASRC_SampleRate_11025HZ = 11025U, /*!< asrc sample rate 11.025KHZ */
kASRC_SampleRate_12000HZ = 12000U, /*!< asrc sample rate 12KHZ */
kASRC_SampleRate_16000HZ = 16000U, /*!< asrc sample rate 16KHZ */
kASRC_SampleRate_22050HZ = 22050U, /*!< asrc sample rate 22.05KHZ */
kASRC_SampleRate_24000HZ = 24000U, /*!< asrc sample rate 24KHZ */
kASRC_SampleRate_30000HZ = 30000U, /*!< asrc sample rate 30KHZ */
kASRC_SampleRate_32000HZ = 32000U, /*!< asrc sample rate 32KHZ */
kASRC_SampleRate_44100HZ = 44100U, /*!< asrc sample rate 44.1KHZ */
kASRC_SampleRate_48000HZ = 48000U, /*!< asrc sample rate 48KHZ */
kASRC_SampleRate_64000HZ = 64000U, /*!< asrc sample rate 64KHZ */
kASRC_SampleRate_88200HZ = 88200U, /*!< asrc sample rate 88.2KHZ */
kASRC_SampleRate_96000HZ = 96000U, /*!< asrc sample rate 96KHZ */
kASRC_SampleRate_128000HZ = 128000U, /*!< asrc sample rate 128KHZ */
kASRC_SampleRate_176400HZ = 176400U, /*!< asrc sample rate 176.4KHZ */
kASRC_SampleRate_192000HZ = 192000U, /*!< asrc sample rate 192KHZ */
};
/*! @brief The ASRC interrupt enable flag
* @anchor _asrc_interrupt_mask
*/
enum
{
kASRC_FPInWaitStateInterruptEnable = ASRC_ASRIER_AFPWE_MASK, /*!< FP in wait state mask */
kASRC_OverLoadInterruptMask = ASRC_ASRIER_AOLIE_MASK, /*!< overload interrupt mask */
kASRC_DataOutputCInterruptMask = ASRC_ASRIER_ADOEC_MASK, /*!< data output c interrupt mask */
kASRC_DataOutputBInterruptMask = ASRC_ASRIER_ADOEB_MASK, /*!< data output b interrupt mask */
kASRC_DataOutputAInterruptMask = ASRC_ASRIER_ADOEA_MASK, /*!< data output a interrupt mask */
kASRC_DataInputCInterruptMask = ASRC_ASRIER_ADIEC_MASK, /*!< data input c interrupt mask */
kASRC_DataInputBInterruptMask = ASRC_ASRIER_ADIEB_MASK, /*!< data input b interrupt mask */
kASRC_DataInputAInterruptMask = ASRC_ASRIER_ADIEA_MASK, /*!< data input a interrupt mask */
};
/*! @brief The ASRC interrupt status
* @anchor _asrc_interrupt_status
*/
enum
{
kASRC_StatusDSLCounterReady = ASRC_ASRSTR_DSLCNT_MASK, /*!< DSL counter */
kASRC_StatusTaskQueueOverLoad = ASRC_ASRSTR_ATQOL_MASK, /*!< task queue overload */
kASRC_StatusPairCOutputOverLoad = ASRC_ASRSTR_AOOLC_MASK, /*!< pair c output overload */
kASRC_StatusPairBOutputOverLoad = ASRC_ASRSTR_AOOLB_MASK, /*!< pair b output overload */
kASRC_StatusPairAOutputOverLoad = ASRC_ASRSTR_AOOLA_MASK, /*!< pair a output overload */
kASRC_StatusPairCInputOverLoad = ASRC_ASRSTR_AIOLC_MASK, /*!< pair c input overload */
kASRC_StatusPairBInputOverLoad = ASRC_ASRSTR_AIOLB_MASK, /*!<pair b input overload */
kASRC_StatusPairAInputOverLoad = ASRC_ASRSTR_AIOLA_MASK, /*!< pair a input overload */
kASRC_StatusPairCOutputOverflow = ASRC_ASRSTR_AODOC_MASK, /*!< pair c output overflow */
kASRC_StatusPairBOutputOverflow = ASRC_ASRSTR_AODOB_MASK, /*!< pair b output overflow */
kASRC_StatusPairAOutputOverflow = ASRC_ASRSTR_AODOA_MASK, /*!< pair a output overflow */
kASRC_StatusPairCInputUnderflow = ASRC_ASRSTR_AIDUC_MASK, /*!< pair c input underflow*/
kASRC_StatusPairBInputUnderflow = ASRC_ASRSTR_AIDUB_MASK, /*!< pair b input under flow */
kASRC_StatusPairAInputUnderflow = ASRC_ASRSTR_AIDUA_MASK, /*!< pair a input underflow*/
kASRC_StatusFPInWaitState = ASRC_ASRSTR_FPWT_MASK, /*!< FP in wait state */
kASRC_StatusOverloadError = ASRC_ASRSTR_AOLE_MASK, /*!< overload error */
kASRC_StatusInputError = kASRC_StatusPairCInputOverLoad | kASRC_StatusPairBInputOverLoad |
kASRC_StatusPairAInputOverLoad | kASRC_StatusPairCInputUnderflow |
kASRC_StatusPairBInputUnderflow |
kASRC_StatusPairAInputUnderflow, /*!< input error status */
kASRC_StatusOutputError = kASRC_StatusPairCOutputOverLoad | kASRC_StatusPairBOutputOverLoad |
kASRC_StatusPairAOutputOverLoad | kASRC_StatusPairCOutputOverflow |
kASRC_StatusPairBOutputOverflow |
kASRC_StatusPairAOutputOverflow, /*!< output error status */
kASRC_StatusPairCOutputReady = ASRC_ASRSTR_AODFC_MASK, /*!< pair c output ready */
kASRC_StatusPairBOutputReady = ASRC_ASRSTR_AODFB_MASK, /*!< pair b output ready */
kASRC_StatusPairAOutputReady = ASRC_ASRSTR_AODFA_MASK, /*!< pair a output ready */
kASRC_StatusPairCInputReady = ASRC_ASRSTR_AIDEC_MASK, /*!< pair c input ready */
kASRC_StatusPairBInputReady = ASRC_ASRSTR_AIDEB_MASK, /*!< pair b input ready */
kASRC_StatusPairAInputReady = ASRC_ASRSTR_AIDEA_MASK, /*!< pair a input ready */
kASRC_StatusPairAInterrupt = kASRC_StatusPairAInputReady | kASRC_StatusPairAOutputReady, /*!< pair A interrupt */
kASRC_StatusPairBInterrupt = kASRC_StatusPairBInputReady | kASRC_StatusPairBOutputReady, /*!< pair B interrupt */
kASRC_StatusPairCInterrupt = kASRC_StatusPairCInputReady | kASRC_StatusPairCOutputReady, /*!< pair C interrupt */
};
/*! @brief ASRC channel pair status
* @anchor _asrc_channel_pair_status
*/
enum
{
kASRC_OutputFifoNearFull = ASRC_ASRFSTA_OAFA_MASK, /*!< channel pair output fifo near full */
kASRC_InputFifoNearEmpty = ASRC_ASRFSTA_IAEA_MASK, /*!< channel pair input fifo near empty */
};
/*! @brief ASRC ideal ratio */
typedef enum _asrc_ratio
{
kASRC_RatioNotUsed = 0U, /*!< ideal ratio not used */
kASRC_RatioUseInternalMeasured =
2U, /*!< ideal ratio use internal measure ratio, can be used for real time streaming audio */
kASRC_RatioUseIdealRatio =
3U, /*!< ideal ratio use manual configure ratio, can be used for the non-real time streaming audio */
} asrc_ratio_t;
/*! @brief Number of channels in audio data */
typedef enum _asrc_audio_channel
{
kASRC_ChannelsNumber1 = 1U, /*!< channel number is 1 */
kASRC_ChannelsNumber2 = 2U, /*!< channel number is 2 */
kASRC_ChannelsNumber3 = 3U, /*!< channel number is 3 */
kASRC_ChannelsNumber4 = 4U, /*!< channel number is 4 */
kASRC_ChannelsNumber5 = 5U, /*!< channel number is 5 */
kASRC_ChannelsNumber6 = 6U, /*!< channel number is 6 */
kASRC_ChannelsNumber7 = 7U, /*!< channel number is 7 */
kASRC_ChannelsNumber8 = 8U, /*!< channel number is 8 */
kASRC_ChannelsNumber9 = 9U, /*!< channel number is 9 */
kASRC_ChannelsNumber10 = 10U, /*!< channel number is 10 */
} asrc_audio_channel_t;
/*! @brief data width */
typedef enum _asrc_data_width
{
kASRC_DataWidth24Bit = 0U, /*!< data width 24bit */
kASRC_DataWidth16Bit = 1U, /*!< data width 16bit */
kASRC_DataWidth8Bit = 2U, /*!< data width 8bit */
} asrc_data_width_t;
/*! @brief data alignment */
typedef enum _asrc_data_align
{
kASRC_DataAlignMSB = 1U, /*!< data alignment MSB */
kASRC_DataAlignLSB = 0U, /*!< data alignment LSB */
} asrc_data_align_t;
/*! @brief sign extension */
typedef enum _asrc_sign_extension
{
kASRC_NoSignExtension = 0U, /*!< no sign extension */
kASRC_SignExtension = 1U, /*!< sign extension */
} asrc_sign_extension_t;
/*! @brief asrc channel pair configuation */
typedef struct _asrc_channel_pair_config
{
asrc_audio_channel_t audioDataChannels; /*!< audio data channel numbers */
asrc_clock_source_t
inClockSource; /*!< input clock source, reference the clock source definition in SOC header file */
uint32_t inSourceClock_Hz; /*!< input source clock frequency */
asrc_clock_source_t
outClockSource; /*!< output clock source, reference the clock source definition in SOC header file */
uint32_t outSourceClock_Hz; /*!< output source clock frequency */
asrc_ratio_t sampleRateRatio; /*!< sample rate ratio type */
asrc_data_width_t inDataWidth; /*!< input data width */
asrc_data_align_t inDataAlign; /*!< input data alignment */
asrc_data_width_t outDataWidth; /*!< output data width */
asrc_data_align_t outDataAlign; /*!< output data alignment */
asrc_sign_extension_t outSignExtension; /*!< output extension */
uint8_t outFifoThreshold; /*!< output fifo threshold */
uint8_t inFifoThreshold; /*!< input fifo threshold */
bool bufStallWhenFifoEmptyFull; /*!< stall Pair A conversion in case of Buffer near empty full condition */
} asrc_channel_pair_config_t;
/*! @brief SAI transfer structure */
typedef struct _asrc_transfer
{
void *inData; /*!< Data address to convert.*/
size_t inDataSize; /*!< input data size. */
void *outData; /*!< Data address to store converted data */
size_t outDataSize; /*!< output data size. */
} asrc_transfer_t;
/*! @brief asrc handler */
typedef struct _asrc_handle asrc_handle_t;
/*! @brief ASRC transfer callback prototype */
typedef void (*asrc_transfer_callback_t)(ASRC_Type *base, asrc_handle_t *handle, status_t status, void *userData);
/*! @brief asrc in handler */
typedef struct _asrc_in_handle
{
asrc_transfer_callback_t callback; /*!< Callback function called at convert complete */
uint32_t sampleWidth; /*!< data width */
uint32_t sampleMask; /*!< data mask */
uint32_t fifoThreshold; /*!< fifo threshold */
uint8_t *asrcQueue[ASRC_XFER_QUEUE_SIZE]; /*!< Transfer queue storing queued transfer */
size_t transferSamples[ASRC_XFER_QUEUE_SIZE]; /*!< Data bytes need to convert */
volatile uint8_t queueUser; /*!< Index for user to queue transfer */
volatile uint8_t queueDriver; /*!< Index for driver to get the transfer data and size */
} asrc_in_handle_t;
/*! @brief output handler */
typedef struct _asrc_out_handle
{
asrc_transfer_callback_t callback; /*!< Callback function called at convert complete */
uint32_t sampleWidth; /*!< data width */
uint32_t fifoThreshold; /*!< fifo threshold */
uint8_t *asrcQueue[ASRC_XFER_QUEUE_SIZE]; /*!< Transfer queue storing queued transfer */
size_t transferSamples[ASRC_XFER_QUEUE_SIZE]; /*!< Data bytes need to convert */
volatile uint8_t queueUser; /*!< Index for user to queue transfer */
volatile uint8_t queueDriver; /*!< Index for driver to get the transfer data and size */
} asrc_out_handle_t;
/*! @brief ASRC handle structure */
struct _asrc_handle
{
ASRC_Type *base; /*!< base address */
uint32_t state; /*!< Transfer status */
void *userData; /*!< Callback parameter passed to callback function*/
asrc_audio_channel_t audioDataChannels; /*!< audio channel number */
asrc_channel_pair_t channelPair; /*!< channel pair mask */
asrc_in_handle_t in; /*!< asrc input handler */
asrc_out_handle_t out; /*!< asrc output handler */
};
/*******************************************************************************
* 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.
* param asrcPeripheralClock_Hz peripheral clock of ASRC.
*/
void ASRC_Init(ASRC_Type *base, uint32_t asrcPeripheralClock_Hz);
/*!
* @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 Do software reset .
*
* This software reset bit is self-clear bit, it will generate a software reset signal inside ASRC.
* After 9 cycles of the ASRC processing clock, this reset process will stop and this bit will cleared
* automatically.
*
* @param base ASRC base pointer
*/
void ASRC_SoftwareReset(ASRC_Type *base);
/*!
* @brief ASRC configure channel pair.
*
* @param base ASRC base pointer.
* @param channelPair index of channel pair, reference _asrc_channel_pair.
* @param config ASRC channel pair configuration pointer.
* @param inputSampleRate input audio data sample rate.
* @param outputSampleRate output audio data sample rate.
*/
status_t ASRC_SetChannelPairConfig(ASRC_Type *base,
asrc_channel_pair_t channelPair,
asrc_channel_pair_config_t *config,
uint32_t inputSampleRate,
uint32_t outputSampleRate);
/*!
* @brief Get output sample buffer size.
*
* @note This API is depends on the ASRC output configuration, should be called after the ASRC_SetChannelPairConfig.
*
* @param base asrc base pointer.
* @param channelPair ASRC channel pair number.
* @param inSampleRate input sample rate.
* @param outSampleRate output sample rate.
* @param inSamplesize input sampleS size.
* @retval output buffer size in byte.
*/
uint32_t ASRC_GetOutSamplesSize(ASRC_Type *base,
asrc_channel_pair_t channelPair,
uint32_t inSampleRate,
uint32_t outSampleRate,
uint32_t inSamplesize);
/*!
* @brief Map register sample width to real sample width.
*
* @note This API is depends on the ASRC configuration, should be called after the ASRC_SetChannelPairConfig.
* @param base asrc base pointer.
* @param channelPair asrc channel pair index.
* @param inWidth ASRC channel pair number.
* @param outWidth input sample rate.
* @retval input sample mask value.
*/
uint32_t ASRC_MapSamplesWidth(ASRC_Type *base, asrc_channel_pair_t channelPair, uint32_t *inWidth, uint32_t *outWidth);
/*!
* @brief Get left samples in fifo.
*
* @param base asrc base pointer.
* @param channelPair ASRC channel pair number.
* @param buffer input sample numbers.
* @param outSampleWidth output sample width.
* @param remainSamples output sample rate.
* @retval remain samples number.
*/
uint32_t ASRC_GetRemainFifoSamples(ASRC_Type *base,
asrc_channel_pair_t channelPair,
uint32_t *buffer,
uint32_t outSampleWidth,
uint32_t remainSamples);
/*!
* @brief ASRC module enable.
*
* @param base ASRC base pointer.
* @param enable true is enable, false is disable
*/
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;
}
}
/*!
* @brief ASRC enable channel pair.
*
* @param base ASRC base pointer.
* @param channelPair channel pair mask value, reference _asrc_channel_pair_mask.
* @param enable true is enable, false is disable.
*/
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));
}
}
/*! @} */
/*!
* @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 @ref _asrc_interrupt_mask.
*/
static inline void ASRC_EnableInterrupt(ASRC_Type *base, uint32_t mask)
{
base->ASRIER |= 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 @ref _asrc_interrupt_mask.
*/
static inline void ASRC_DisableInterrupt(ASRC_Type *base, uint32_t mask)
{
base->ASRIER &= ~mask;
}
/*! @} */
/*!
* @name Status
* @{
*/
/*!
* @brief Gets the ASRC 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_GetStatus(ASRC_Type *base)
{
return base->ASRSTR;
}
/*!
* @brief Gets the ASRC channel pair initialization state.
*
* @param base ASRC base pointer
* @param channel ASRC channel pair.
* @return ASRC Tx status flag value. Use the Status Mask to get the status value needed.
*/
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;
}
/*!
* @brief Gets the ASRC channel A fifo a status flag state.
*
* @param base ASRC base pointer
* @param channelPair ASRC channel pair.
* @return ASRC channel pair a fifo status flag value. Use the Status Mask to get the status value needed.
*/
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);
}
/*! @} */
/*!
* @name Bus Operations
* @{
*/
/*!
* @brief Writes data into ASRC channel pair FIFO.
* Note: ASRC fifo width is 24bit.
* @param base ASRC base pointer.
* @param channelPair ASRC channel pair.
* @param data Data needs to be written.
*/
static inline void ASRC_ChannelPairWriteData(ASRC_Type *base, asrc_channel_pair_t channelPair, uint32_t data)
{
ASRC_ASRDI(base, channelPair) = data;
}
/*!
* @brief Read data from ASRC channel pair FIFO.
* Note: ASRC fifo width is 24bit.
*
* @param base ASRC base pointer.
* @param channelPair ASRC channel pair.
* @retval value read from fifo.
*/
static inline uint32_t ASRC_ChannelPairReadData(ASRC_Type *base, asrc_channel_pair_t channelPair)
{
return ASRC_ASRDO(base, channelPair);
}
/*!
* @brief Get input data fifo address.
* Note: ASRC fifo width is 24bit.
*
* @param base ASRC base pointer.
* @param channelPair ASRC channel pair.
*/
static inline uint32_t ASRC_GetInputDataRegisterAddress(ASRC_Type *base, asrc_channel_pair_t channelPair)
{
return (uint32_t)ASRC_ASRDI_ADDR(base, channelPair);
}
/*!
* @brief Get output data fifo address.
* Note: ASRC fifo width is 24bit.
*
* @param base ASRC base pointer.
* @param channelPair ASRC channel pair.
*/
static inline uint32_t ASRC_GetOutputDataRegisterAddress(ASRC_Type *base, asrc_channel_pair_t channelPair)
{
return (uint32_t)ASRC_ASRDO_ADDR(base, channelPair);
}
/*!
* @brief ASRC configure ideal ratio.
* The ideal ratio should be used when input clock source is not avalible.
*
* @param base ASRC base pointer.
* @param channelPair ASRC channel pair.
* @param inputSampleRate input audio data sample rate.
* @param outputSampleRate output audio data sample rate.
*/
status_t ASRC_SetIdealRatioConfig(ASRC_Type *base,
asrc_channel_pair_t channelPair,
uint32_t inputSampleRate,
uint32_t outputSampleRate);
/*! @} */
/*!
* @name Transactional
* @{
*/
/*!
* @brief ASRC configure channel pair.
*
* @param base ASRC base pointer.
* @param handle ASRC transactional handle pointer.
* @param config ASRC channel pair configuration pointer.
* @param inputSampleRate input audio data sample rate.
* @param outputSampleRate output audio data sample rate.
*/
status_t ASRC_TransferSetChannelPairConfig(ASRC_Type *base,
asrc_handle_t *handle,
asrc_channel_pair_config_t *config,
uint32_t inputSampleRate,
uint32_t outputSampleRate);
/*!
* @brief Initializes the ASRC handle.
*
* This function initializes the handle for the ASRC transactional APIs. Call
* this function once to get the handle initialized.
*
* @param base ASRC base pointer
* @param handle ASRC handle pointer.
* @param channelPair ASRC channel pair.
* @param inCallback Pointer to the user callback function.
* @param outCallback Pointer to the user callback function.
* @param userData User parameter passed to the callback function
*/
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);
/*!
* @brief Performs an interrupt non-blocking convert on asrc.
*
* @note This API returns immediately after the transfer initiates, application should check the wait and check the
* callback status.
*
* @param base asrc base pointer.
* @param handle Pointer to the asrc_handle_t structure which stores the transfer state.
* @param xfer Pointer to the ASRC_transfer_t structure.
* @retval kStatus_Success Successfully started the data receive.
* @retval kStatus_ASRCBusy Previous receive still not finished.
*/
status_t ASRC_TransferNonBlocking(ASRC_Type *base, asrc_handle_t *handle, asrc_transfer_t *xfer);
/*!
* @brief Performs an blocking convert on asrc.
*
* @note This API returns immediately after the convert finished.
*
* @param base asrc base pointer.
* @param channelPair channel pair index.
* @param xfer Pointer to the ASRC_transfer_t structure.
* @retval kStatus_Success Successfully started the data receive.
*/
status_t ASRC_TransferBlocking(ASRC_Type *base, asrc_channel_pair_t channelPair, asrc_transfer_t *xfer);
/*!
* @brief Get converted byte count.
*
* @param base ASRC base pointer.
* @param handle Pointer to the asrc_handle_t structure which stores the transfer state.
* @param count Bytes count sent.
* @retval kStatus_Success Succeed get the transfer count.
* @retval kStatus_ASRCIdle There is not a non-blocking transaction currently in progress.
*/
status_t ASRC_TransferGetConvertedCount(ASRC_Type *base, asrc_handle_t *handle, size_t *count);
/*!
* @brief Aborts the current convert.
*
* @note This API can be called any time when an interrupt non-blocking transfer initiates
* to abort the transfer early.
*
* @param base ASRC base pointer.
* @param handle Pointer to the asrc_handle_t structure which stores the transfer state.
*/
void ASRC_TransferAbortConvert(ASRC_Type *base, asrc_handle_t *handle);
/*!
* @brief Terminate all ASRC convert.
*
* This function will clear all transfer slots buffered in the asrc queue. If users only want to abort the
* current transfer slot, please call ASRC_TransferAbortConvert.
*
* @param base ASRC base pointer.
* @param handle ASRC eDMA handle pointer.
*/
void ASRC_TransferTerminateConvert(ASRC_Type *base, asrc_handle_t *handle);
/*!
* @brief ASRC convert interrupt handler.
*
* @param base ASRC base pointer.
* @param handle Pointer to the asrc_handle_t structure.
*/
void ASRC_TransferHandleIRQ(ASRC_Type *base, asrc_handle_t *handle);
/*! @} */
#if defined(__cplusplus)
}
#endif /*_cplusplus*/
/*! @} */
#endif /* _FSL_ASRC_H_ */
View Git Blame Copy Permalink