diff options
Diffstat (limited to '')
| -rw-r--r-- | bsps/arm/imxrt/mcux-sdk/drivers/asrc/fsl_asrc.h | 761 |
1 files changed, 761 insertions, 0 deletions
diff --git a/bsps/arm/imxrt/mcux-sdk/drivers/asrc/fsl_asrc.h b/bsps/arm/imxrt/mcux-sdk/drivers/asrc/fsl_asrc.h new file mode 100644 index 0000000000..e4f8ce384a --- /dev/null +++ b/bsps/arm/imxrt/mcux-sdk/drivers/asrc/fsl_asrc.h @@ -0,0 +1,761 @@ +/* + * 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_ */ |