1203 lines
42 KiB
C
1203 lines
42 KiB
C
/*
|
|
* Copyright (c) 2018, Freescale Semiconductor, Inc.
|
|
* Copyright 2019-2020 NXP
|
|
* All rights reserved.
|
|
*
|
|
* SPDX-License-Identifier: BSD-3-Clause
|
|
*/
|
|
|
|
#ifndef _FSL_PDM_H_
|
|
#define _FSL_PDM_H_
|
|
|
|
#include "fsl_common.h"
|
|
|
|
/*!
|
|
* @addtogroup pdm_driver PDM Driver
|
|
* @{
|
|
*/
|
|
|
|
/*******************************************************************************
|
|
* Definitions
|
|
******************************************************************************/
|
|
|
|
/*! @name Driver version */
|
|
/*@{*/
|
|
#define FSL_PDM_DRIVER_VERSION (MAKE_VERSION(2, 7, 1)) /*!< Version 2.7.1 */
|
|
/*@}*/
|
|
|
|
/*! @brief PDM XFER QUEUE SIZE */
|
|
#define PDM_XFER_QUEUE_SIZE (4U)
|
|
|
|
/*! @brief PDM return status*/
|
|
enum
|
|
{
|
|
kStatus_PDM_Busy = MAKE_STATUS(kStatusGroup_PDM, 0), /*!< PDM is busy. */
|
|
#if (defined(FSL_FEATURE_PDM_HAS_STATUS_LOW_FREQ) && (FSL_FEATURE_PDM_HAS_STATUS_LOW_FREQ == 1U))
|
|
kStatus_PDM_CLK_LOW = MAKE_STATUS(kStatusGroup_PDM, 1), /*!< PDM clock frequency low */
|
|
#endif
|
|
kStatus_PDM_FIFO_ERROR = MAKE_STATUS(kStatusGroup_PDM, 2), /*!< PDM FIFO underrun or overflow */
|
|
kStatus_PDM_QueueFull = MAKE_STATUS(kStatusGroup_PDM, 3), /*!< PDM FIFO underrun or overflow */
|
|
kStatus_PDM_Idle = MAKE_STATUS(kStatusGroup_PDM, 4), /*!< PDM is idle */
|
|
kStatus_PDM_Output_ERROR = MAKE_STATUS(kStatusGroup_PDM, 5), /*!< PDM is output error */
|
|
kStatus_PDM_ChannelConfig_Failed = MAKE_STATUS(kStatusGroup_PDM, 6), /*!< PDM channel config failed */
|
|
kStatus_PDM_HWVAD_VoiceDetected = MAKE_STATUS(kStatusGroup_PDM, 7), /*!< PDM hwvad voice detected */
|
|
kStatus_PDM_HWVAD_Error = MAKE_STATUS(kStatusGroup_PDM, 8), /*!< PDM hwvad error */
|
|
|
|
};
|
|
|
|
/*! @brief The PDM interrupt enable flag */
|
|
enum _pdm_interrupt_enable
|
|
{
|
|
kPDM_ErrorInterruptEnable = PDM_CTRL_1_ERREN_MASK, /*!< PDM channel error interrupt enable. */
|
|
kPDM_FIFOInterruptEnable = PDM_CTRL_1_DISEL(2U), /*!< PDM channel FIFO interrupt */
|
|
};
|
|
|
|
/*! @brief The PDM status */
|
|
enum _pdm_internal_status
|
|
{
|
|
kPDM_StatusDfBusyFlag = (int)PDM_STAT_BSY_FIL_MASK, /*!< Decimation filter is busy processing data */
|
|
kPDM_StatusFIRFilterReady = PDM_STAT_FIR_RDY_MASK, /*!< FIR filter data is ready */
|
|
#if (defined(FSL_FEATURE_PDM_HAS_STATUS_LOW_FREQ) && (FSL_FEATURE_PDM_HAS_STATUS_LOW_FREQ == 1U))
|
|
kPDM_StatusFrequencyLow = PDM_STAT_LOWFREQF_MASK, /*!< Mic app clock frequency not high enough */
|
|
#endif
|
|
kPDM_StatusCh0FifoDataAvaliable = PDM_STAT_CH0F_MASK, /*!< channel 0 fifo data reached watermark level */
|
|
kPDM_StatusCh1FifoDataAvaliable = PDM_STAT_CH1F_MASK, /*!< channel 1 fifo data reached watermark level */
|
|
kPDM_StatusCh2FifoDataAvaliable = PDM_STAT_CH2F_MASK, /*!< channel 2 fifo data reached watermark level */
|
|
kPDM_StatusCh3FifoDataAvaliable = PDM_STAT_CH3F_MASK, /*!< channel 3 fifo data reached watermark level */
|
|
#if !defined(FSL_FEATURE_PDM_CHANNEL_NUM) || (FSL_FEATURE_PDM_CHANNEL_NUM == 8U)
|
|
kPDM_StatusCh4FifoDataAvaliable = PDM_STAT_CH4F_MASK, /*!< channel 4 fifo data reached watermark level */
|
|
kPDM_StatusCh5FifoDataAvaliable = PDM_STAT_CH5F_MASK, /*!< channel 5 fifo data reached watermark level */
|
|
kPDM_StatusCh6FifoDataAvaliable = PDM_STAT_CH6F_MASK, /*!< channel 6 fifo data reached watermark level */
|
|
kPDM_StatusCh7FifoDataAvaliable = PDM_STAT_CH7F_MASK, /*!< channel 7 fifo data reached watermark level */
|
|
#endif
|
|
};
|
|
|
|
/*! @brief PDM channel enable mask */
|
|
enum _pdm_channel_enable_mask
|
|
{
|
|
kPDM_EnableChannel0 = PDM_STAT_CH0F_MASK, /*!< channgel 0 enable mask */
|
|
kPDM_EnableChannel1 = PDM_STAT_CH1F_MASK, /*!< channgel 1 enable mask */
|
|
kPDM_EnableChannel2 = PDM_STAT_CH2F_MASK, /*!< channgel 2 enable mask */
|
|
kPDM_EnableChannel3 = PDM_STAT_CH3F_MASK, /*!< channgel 3 enable mask */
|
|
#if !defined(FSL_FEATURE_PDM_CHANNEL_NUM) || (FSL_FEATURE_PDM_CHANNEL_NUM == 8U)
|
|
kPDM_EnableChannel4 = PDM_STAT_CH4F_MASK, /*!< channgel 4 enable mask */
|
|
kPDM_EnableChannel5 = PDM_STAT_CH5F_MASK, /*!< channgel 5 enable mask */
|
|
kPDM_EnableChannel6 = PDM_STAT_CH6F_MASK, /*!< channgel 6 enable mask */
|
|
kPDM_EnableChannel7 = PDM_STAT_CH7F_MASK, /*!< channgel 7 enable mask */
|
|
|
|
kPDM_EnableChannelAll = kPDM_EnableChannel0 | kPDM_EnableChannel1 | kPDM_EnableChannel2 | kPDM_EnableChannel3 |
|
|
kPDM_EnableChannel4 | kPDM_EnableChannel5 | kPDM_EnableChannel6 | kPDM_EnableChannel7,
|
|
#else
|
|
kPDM_EnableChannelAll = kPDM_EnableChannel0 | kPDM_EnableChannel1 | kPDM_EnableChannel2 | kPDM_EnableChannel3,
|
|
#endif
|
|
};
|
|
|
|
/*! @brief The PDM fifo status */
|
|
enum _pdm_fifo_status
|
|
{
|
|
kPDM_FifoStatusUnderflowCh0 = PDM_FIFO_STAT_FIFOUND0_MASK, /*!< channel0 fifo status underflow */
|
|
kPDM_FifoStatusUnderflowCh1 = PDM_FIFO_STAT_FIFOUND1_MASK, /*!< channel1 fifo status underflow */
|
|
kPDM_FifoStatusUnderflowCh2 = PDM_FIFO_STAT_FIFOUND2_MASK, /*!< channel2 fifo status underflow */
|
|
kPDM_FifoStatusUnderflowCh3 = PDM_FIFO_STAT_FIFOUND3_MASK, /*!< channel3 fifo status underflow */
|
|
#if !defined(FSL_FEATURE_PDM_CHANNEL_NUM) || (FSL_FEATURE_PDM_CHANNEL_NUM == 8U)
|
|
kPDM_FifoStatusUnderflowCh4 = PDM_FIFO_STAT_FIFOUND4_MASK, /*!< channel4 fifo status underflow */
|
|
kPDM_FifoStatusUnderflowCh5 = PDM_FIFO_STAT_FIFOUND5_MASK, /*!< channel5 fifo status underflow */
|
|
kPDM_FifoStatusUnderflowCh6 = PDM_FIFO_STAT_FIFOUND6_MASK, /*!< channel6 fifo status underflow */
|
|
kPDM_FifoStatusUnderflowCh7 = PDM_FIFO_STAT_FIFOUND6_MASK, /*!< channel7 fifo status underflow */
|
|
#endif
|
|
|
|
kPDM_FifoStatusOverflowCh0 = PDM_FIFO_STAT_FIFOOVF0_MASK, /*!< channel0 fifo status overflow */
|
|
kPDM_FifoStatusOverflowCh1 = PDM_FIFO_STAT_FIFOOVF1_MASK, /*!< channel1 fifo status overflow */
|
|
kPDM_FifoStatusOverflowCh2 = PDM_FIFO_STAT_FIFOOVF2_MASK, /*!< channel2 fifo status overflow */
|
|
kPDM_FifoStatusOverflowCh3 = PDM_FIFO_STAT_FIFOOVF3_MASK, /*!< channel3 fifo status overflow */
|
|
#if !defined(FSL_FEATURE_PDM_CHANNEL_NUM) || (FSL_FEATURE_PDM_CHANNEL_NUM == 8U)
|
|
kPDM_FifoStatusOverflowCh4 = PDM_FIFO_STAT_FIFOOVF4_MASK, /*!< channel4 fifo status overflow */
|
|
kPDM_FifoStatusOverflowCh5 = PDM_FIFO_STAT_FIFOOVF5_MASK, /*!< channel5 fifo status overflow */
|
|
kPDM_FifoStatusOverflowCh6 = PDM_FIFO_STAT_FIFOOVF6_MASK, /*!< channel6 fifo status overflow */
|
|
kPDM_FifoStatusOverflowCh7 = PDM_FIFO_STAT_FIFOOVF7_MASK, /*!< channel7 fifo status overflow */
|
|
#endif
|
|
};
|
|
|
|
#if defined(FSL_FEATURE_PDM_HAS_RANGE_CTRL) && FSL_FEATURE_PDM_HAS_RANGE_CTRL
|
|
/*! @brief The PDM output status */
|
|
enum _pdm_range_status
|
|
{
|
|
kPDM_RangeStatusUnderFlowCh0 = PDM_RANGE_STAT_RANGEUNF0_MASK, /*!< channel0 range status underflow */
|
|
kPDM_RangeStatusUnderFlowCh1 = PDM_RANGE_STAT_RANGEUNF1_MASK, /*!< channel1 range status underflow */
|
|
kPDM_RangeStatusUnderFlowCh2 = PDM_RANGE_STAT_RANGEUNF2_MASK, /*!< channel2 range status underflow */
|
|
kPDM_RangeStatusUnderFlowCh3 = PDM_RANGE_STAT_RANGEUNF3_MASK, /*!< channel3 range status underflow */
|
|
#if !defined(FSL_FEATURE_PDM_CHANNEL_NUM) || (FSL_FEATURE_PDM_CHANNEL_NUM == 8U)
|
|
kPDM_RangeStatusUnderFlowCh4 = PDM_RANGE_STAT_RANGEUNF4_MASK, /*!< channel4 range status underflow */
|
|
kPDM_RangeStatusUnderFlowCh5 = PDM_RANGE_STAT_RANGEUNF5_MASK, /*!< channel5 range status underflow */
|
|
kPDM_RangeStatusUnderFlowCh6 = PDM_RANGE_STAT_RANGEUNF6_MASK, /*!< channel6 range status underflow */
|
|
kPDM_RangeStatusUnderFlowCh7 = PDM_RANGE_STAT_RANGEUNF7_MASK, /*!< channel7 range status underflow */
|
|
#endif
|
|
kPDM_RangeStatusOverFlowCh0 = PDM_RANGE_STAT_RANGEOVF0_MASK, /*!< channel0 range status overflow */
|
|
kPDM_RangeStatusOverFlowCh1 = PDM_RANGE_STAT_RANGEOVF1_MASK, /*!< channel1 range status overflow */
|
|
kPDM_RangeStatusOverFlowCh2 = PDM_RANGE_STAT_RANGEOVF2_MASK, /*!< channel2 range status overflow */
|
|
kPDM_RangeStatusOverFlowCh3 = PDM_RANGE_STAT_RANGEOVF3_MASK, /*!< channel3 range status overflow */
|
|
#if !defined(FSL_FEATURE_PDM_CHANNEL_NUM) || (FSL_FEATURE_PDM_CHANNEL_NUM == 8U)
|
|
kPDM_RangeStatusOverFlowCh4 = PDM_RANGE_STAT_RANGEOVF4_MASK, /*!< channel4 range status overflow */
|
|
kPDM_RangeStatusOverFlowCh5 = PDM_RANGE_STAT_RANGEOVF5_MASK, /*!< channel5 range status overflow */
|
|
kPDM_RangeStatusOverFlowCh6 = PDM_RANGE_STAT_RANGEOVF6_MASK, /*!< channel6 range status overflow */
|
|
kPDM_RangeStatusOverFlowCh7 = PDM_RANGE_STAT_RANGEOVF7_MASK, /*!< channel7 range status overflow */
|
|
#endif
|
|
};
|
|
#else
|
|
/*! @brief The PDM output status */
|
|
enum _pdm_output_status
|
|
{
|
|
kPDM_OutputStatusUnderFlowCh0 = PDM_OUT_STAT_OUTUNF0_MASK, /*!< channel0 output status underflow */
|
|
kPDM_OutputStatusUnderFlowCh1 = PDM_OUT_STAT_OUTUNF1_MASK, /*!< channel1 output status underflow */
|
|
kPDM_OutputStatusUnderFlowCh2 = PDM_OUT_STAT_OUTUNF2_MASK, /*!< channel2 output status underflow */
|
|
kPDM_OutputStatusUnderFlowCh3 = PDM_OUT_STAT_OUTUNF3_MASK, /*!< channel3 output status underflow */
|
|
#if !defined(FSL_FEATURE_PDM_CHANNEL_NUM) || (FSL_FEATURE_PDM_CHANNEL_NUM == 8U)
|
|
kPDM_OutputStatusUnderFlowCh4 = PDM_OUT_STAT_OUTUNF4_MASK, /*!< channel4 output status underflow */
|
|
kPDM_OutputStatusUnderFlowCh5 = PDM_OUT_STAT_OUTUNF5_MASK, /*!< channel5 output status underflow */
|
|
kPDM_OutputStatusUnderFlowCh6 = PDM_OUT_STAT_OUTUNF6_MASK, /*!< channel6 output status underflow */
|
|
kPDM_OutputStatusUnderFlowCh7 = PDM_OUT_STAT_OUTUNF7_MASK, /*!< channel7 output status underflow */
|
|
#endif
|
|
kPDM_OutputStatusOverFlowCh0 = PDM_OUT_STAT_OUTOVF0_MASK, /*!< channel0 output status overflow */
|
|
kPDM_OutputStatusOverFlowCh1 = PDM_OUT_STAT_OUTOVF1_MASK, /*!< channel1 output status overflow */
|
|
kPDM_OutputStatusOverFlowCh2 = PDM_OUT_STAT_OUTOVF2_MASK, /*!< channel2 output status overflow */
|
|
kPDM_OutputStatusOverFlowCh3 = PDM_OUT_STAT_OUTOVF3_MASK, /*!< channel3 output status overflow */
|
|
#if !defined(FSL_FEATURE_PDM_CHANNEL_NUM) || (FSL_FEATURE_PDM_CHANNEL_NUM == 8U)
|
|
kPDM_OutputStatusOverFlowCh4 = PDM_OUT_STAT_OUTOVF4_MASK, /*!< channel4 output status overflow */
|
|
kPDM_OutputStatusOverFlowCh5 = PDM_OUT_STAT_OUTOVF5_MASK, /*!< channel5 output status overflow */
|
|
kPDM_OutputStatusOverFlowCh6 = PDM_OUT_STAT_OUTOVF6_MASK, /*!< channel6 output status overflow */
|
|
kPDM_OutputStatusOverFlowCh7 = PDM_OUT_STAT_OUTOVF7_MASK, /*!< channel7 output status overflow */
|
|
#endif
|
|
};
|
|
#endif
|
|
|
|
#if (defined(FSL_FEATURE_PDM_HAS_DC_OUT_CTRL) && (FSL_FEATURE_PDM_HAS_DC_OUT_CTRL))
|
|
/*! @brief PDM DC remover configurations */
|
|
typedef enum _pdm_dc_remover
|
|
{
|
|
kPDM_DcRemoverCutOff20Hz = 0U, /*!< DC remover cut off 20HZ */
|
|
kPDM_DcRemoverCutOff13Hz = 1U, /*!< DC remover cut off 13.3HZ */
|
|
kPDM_DcRemoverCutOff40Hz = 2U, /*!< DC remover cut off 40HZ */
|
|
kPDM_DcRemoverBypass = 3U, /*!< DC remover bypass */
|
|
} pdm_dc_remover_t;
|
|
#else
|
|
/*! @brief PDM DC remover configurations */
|
|
typedef enum _pdm_dc_remover
|
|
{
|
|
kPDM_DcRemoverCutOff21Hz = 0U, /*!< DC remover cut off 21HZ */
|
|
kPDM_DcRemoverCutOff83Hz = 1U, /*!< DC remover cut off 83HZ */
|
|
kPDM_DcRemoverCutOff152Hz = 2U, /*!< DC remover cut off 152HZ */
|
|
kPDM_DcRemoverBypass = 3U, /*!< DC remover bypass */
|
|
} pdm_dc_remover_t;
|
|
#endif
|
|
|
|
/*! @brief PDM decimation filter quality mode */
|
|
typedef enum _pdm_df_quality_mode
|
|
{
|
|
kPDM_QualityModeMedium = 0U, /*!< quality mode memdium */
|
|
kPDM_QualityModeHigh = 1U, /*!< quality mode high */
|
|
kPDM_QualityModeLow = 7U, /*!< quality mode low */
|
|
kPDM_QualityModeVeryLow0 = 6U, /*!< quality mode very low0 */
|
|
kPDM_QualityModeVeryLow1 = 5U, /*!< quality mode very low1 */
|
|
kPDM_QualityModeVeryLow2 = 4U, /*!< quality mode very low2 */
|
|
} pdm_df_quality_mode_t;
|
|
|
|
/*! @brief PDM quality mode K factor */
|
|
enum _pdm_qulaity_mode_k_factor
|
|
{
|
|
kPDM_QualityModeHighKFactor = 1U, /*!< high quality mode K factor = 1 / 2 */
|
|
kPDM_QualityModeMediumKFactor = 2U, /*!< medium/very low0 quality mode K factor = 2 / 2 */
|
|
kPDM_QualityModeLowKFactor = 4U, /*!< low/very low1 quality mode K factor = 4 / 2 */
|
|
kPDM_QualityModeVeryLow2KFactor = 8U, /*!< very low2 quality mode K factor = 8 / 2 */
|
|
};
|
|
|
|
/*! @brief PDM decimation filter output gain */
|
|
typedef enum _pdm_df_output_gain
|
|
{
|
|
kPDM_DfOutputGain0 = 0U, /*!< Decimation filter output gain 0 */
|
|
kPDM_DfOutputGain1 = 1U, /*!< Decimation filter output gain 1 */
|
|
kPDM_DfOutputGain2 = 2U, /*!< Decimation filter output gain 2 */
|
|
kPDM_DfOutputGain3 = 3U, /*!< Decimation filter output gain 3 */
|
|
kPDM_DfOutputGain4 = 4U, /*!< Decimation filter output gain 4 */
|
|
kPDM_DfOutputGain5 = 5U, /*!< Decimation filter output gain 5 */
|
|
kPDM_DfOutputGain6 = 6U, /*!< Decimation filter output gain 6 */
|
|
kPDM_DfOutputGain7 = 7U, /*!< Decimation filter output gain 7 */
|
|
kPDM_DfOutputGain8 = 8U, /*!< Decimation filter output gain 8 */
|
|
kPDM_DfOutputGain9 = 9U, /*!< Decimation filter output gain 9 */
|
|
kPDM_DfOutputGain10 = 0xAU, /*!< Decimation filter output gain 10 */
|
|
kPDM_DfOutputGain11 = 0xBU, /*!< Decimation filter output gain 11 */
|
|
kPDM_DfOutputGain12 = 0xCU, /*!< Decimation filter output gain 12 */
|
|
kPDM_DfOutputGain13 = 0xDU, /*!< Decimation filter output gain 13 */
|
|
kPDM_DfOutputGain14 = 0xEU, /*!< Decimation filter output gain 14 */
|
|
kPDM_DfOutputGain15 = 0xFU, /*!< Decimation filter output gain 15 */
|
|
} pdm_df_output_gain_t;
|
|
|
|
/*! @brief PDM data width */
|
|
enum _pdm_data_width
|
|
{
|
|
#if defined(FSL_FEATURE_PDM_FIFO_WIDTH) && (FSL_FEATURE_PDM_FIFO_WIDTH != 2U)
|
|
kPDM_DataWwidth24 = 3U, /*!< PDM data width 24bit */
|
|
kPDM_DataWwidth32 = 4U, /*!< PDM data width 32bit */
|
|
#else
|
|
kPDM_DataWdith16 = 2U, /*!< PDM data width 16bit */
|
|
#endif
|
|
};
|
|
|
|
/*! @brief PDM channel configurations */
|
|
typedef struct _pdm_channel_config
|
|
{
|
|
#if (defined(FSL_FEATURE_PDM_HAS_DC_OUT_CTRL) && (FSL_FEATURE_PDM_HAS_DC_OUT_CTRL))
|
|
pdm_dc_remover_t outputCutOffFreq; /*!< PDM output DC remover cut off frequency */
|
|
#endif
|
|
|
|
#if !(defined(FSL_FEATURE_PDM_DC_CTRL_VALUE_FIXED) && (FSL_FEATURE_PDM_DC_CTRL_VALUE_FIXED))
|
|
pdm_dc_remover_t cutOffFreq; /*!< DC remover cut off frequency */
|
|
#endif
|
|
|
|
pdm_df_output_gain_t gain; /*!< Decimation Filter Output Gain */
|
|
} pdm_channel_config_t;
|
|
|
|
/*! @brief PDM user configuration structure */
|
|
typedef struct _pdm_config
|
|
{
|
|
bool
|
|
enableDoze; /*!< This module will enter disable/low leakage mode if DOZEN is active with ipg_doze is asserted */
|
|
uint8_t fifoWatermark; /*!< Watermark value for FIFO */
|
|
pdm_df_quality_mode_t qualityMode; /*!< Quality mode */
|
|
uint8_t cicOverSampleRate; /*!< CIC filter over sampling rate */
|
|
} pdm_config_t;
|
|
|
|
/*! @brief PDM voice activity detector interrupt type */
|
|
enum _pdm_hwvad_interrupt_enable
|
|
{
|
|
kPDM_HwvadErrorInterruptEnable = PDM_VAD0_CTRL_1_VADERIE_MASK, /*!< PDM channel HWVAD error interrupt enable. */
|
|
kPDM_HwvadInterruptEnable = PDM_VAD0_CTRL_1_VADIE_MASK, /*!< PDM channel HWVAD interrupt */
|
|
};
|
|
|
|
/*! @brief The PDM hwvad interrupt status flag */
|
|
enum _pdm_hwvad_int_status
|
|
{
|
|
kPDM_HwvadStatusInputSaturation = PDM_VAD0_STAT_VADINSATF_MASK, /*!< HWVAD saturation condition */
|
|
kPDM_HwvadStatusVoiceDetectFlag = PDM_VAD0_STAT_VADIF_MASK, /*!< HWVAD voice detect interrupt triggered */
|
|
};
|
|
|
|
/*! @brief High pass filter configure cut-off frequency*/
|
|
typedef enum _pdm_hwvad_hpf_config
|
|
{
|
|
kPDM_HwvadHpfBypassed = 0x0U, /*!< High-pass filter bypass */
|
|
kPDM_HwvadHpfCutOffFreq1750Hz = 0x1U, /*!< High-pass filter cut off frequency 1750HZ */
|
|
kPDM_HwvadHpfCutOffFreq215Hz = 0x2U, /*!< High-pass filter cut off frequency 215HZ */
|
|
kPDM_HwvadHpfCutOffFreq102Hz = 0x3U, /*!< High-pass filter cut off frequency 102HZ */
|
|
} pdm_hwvad_hpf_config_t;
|
|
|
|
/*! @brief HWVAD internal filter status */
|
|
typedef enum _pdm_hwvad_filter_status
|
|
{
|
|
kPDM_HwvadInternalFilterNormalOperation = 0U, /*!< internal filter ready for normal operation */
|
|
kPDM_HwvadInternalFilterInitial = PDM_VAD0_CTRL_1_VADST10_MASK, /*!< interla filter are initial */
|
|
} pdm_hwvad_filter_status_t;
|
|
|
|
/*! @brief PDM voice activity detector user configuration structure */
|
|
typedef struct _pdm_hwvad_config
|
|
{
|
|
uint8_t channel; /*!< Which channel uses voice activity detector */
|
|
uint8_t initializeTime; /*!< Number of frames or samples to initialize voice activity detector. */
|
|
uint8_t cicOverSampleRate; /*!< CIC filter over sampling rate */
|
|
|
|
uint8_t inputGain; /*!< Voice activity detector input gain */
|
|
uint32_t frameTime; /*!< Voice activity frame time */
|
|
pdm_hwvad_hpf_config_t cutOffFreq; /*!< High pass filter cut off frequency */
|
|
bool enableFrameEnergy; /*!< If frame energy enabled, true means enable */
|
|
bool enablePreFilter; /*!< If pre-filter enabled */
|
|
} pdm_hwvad_config_t;
|
|
|
|
/*! @brief PDM voice activity detector noise filter user configuration structure */
|
|
typedef struct _pdm_hwvad_noise_filter
|
|
{
|
|
bool enableAutoNoiseFilter; /*!< If noise fileter automatically activated, true means enable */
|
|
bool enableNoiseMin; /*!< If Noise minimum block enabled, true means enabled */
|
|
bool enableNoiseDecimation; /*!< If enable noise input decimation */
|
|
bool enableNoiseDetectOR; /*!< Enables a OR logic in the output of minimum noise estimator block */
|
|
uint32_t noiseFilterAdjustment; /*!< The adjustment value of the noise filter */
|
|
uint32_t noiseGain; /*!< Gain value for the noise energy or envelope estimated */
|
|
} pdm_hwvad_noise_filter_t;
|
|
|
|
/*! @brief PDM voice activity detector zero cross detector result */
|
|
typedef enum _pdm_hwvad_zcd_result
|
|
{
|
|
kPDM_HwvadResultOREnergyBasedDetection =
|
|
0U, /*!< zero cross detector result will be OR with energy based detection */
|
|
kPDM_HwvadResultANDEnergyBasedDetection =
|
|
1U, /*!< zero cross detector result will be AND with energy based detection */
|
|
} pdm_hwvad_zcd_result_t;
|
|
|
|
/*! @brief PDM voice activity detector zero cross detector configuration structure */
|
|
typedef struct _pdm_hwvad_zero_cross_detector
|
|
{
|
|
bool enableAutoThreshold; /*!< If ZCD auto-threshold enabled, true means enabled. */
|
|
pdm_hwvad_zcd_result_t zcdAnd; /*!< Is ZCD result is AND'ed with energy-based detection, false means OR'ed */
|
|
uint32_t threshold; /*!< The adjustment value of the noise filter */
|
|
uint32_t adjustmentThreshold; /*!< Gain value for the noise energy or envelope estimated */
|
|
} pdm_hwvad_zero_cross_detector_t;
|
|
|
|
/*! @brief PDM SDMA transfer structure */
|
|
typedef struct _pdm_transfer
|
|
{
|
|
volatile uint8_t *data; /*!< Data start address to transfer. */
|
|
volatile size_t dataSize; /*!< Total Transfer bytes size. */
|
|
} pdm_transfer_t;
|
|
|
|
/*! @brief PDM handle */
|
|
typedef struct _pdm_handle pdm_handle_t;
|
|
|
|
/*! @brief PDM transfer callback prototype */
|
|
typedef void (*pdm_transfer_callback_t)(PDM_Type *base, pdm_handle_t *handle, status_t status, void *userData);
|
|
|
|
/*! @brief PDM HWVAD callback prototype */
|
|
typedef void (*pdm_hwvad_callback_t)(status_t status, void *userData);
|
|
/*! @brief PDM HWVAD notification structure */
|
|
typedef struct _pdm_hwvad_notification
|
|
{
|
|
pdm_hwvad_callback_t callback;
|
|
void *userData;
|
|
} pdm_hwvad_notification_t;
|
|
|
|
/*! @brief PDM handle structure */
|
|
struct _pdm_handle
|
|
{
|
|
uint32_t state; /*!< Transfer status */
|
|
pdm_transfer_callback_t callback; /*!< Callback function called at transfer event*/
|
|
void *userData; /*!< Callback parameter passed to callback function*/
|
|
|
|
pdm_transfer_t pdmQueue[PDM_XFER_QUEUE_SIZE]; /*!< Transfer queue storing queued transfer */
|
|
size_t transferSize[PDM_XFER_QUEUE_SIZE]; /*!< Data bytes need to transfer */
|
|
volatile uint8_t queueUser; /*!< Index for user to queue transfer */
|
|
volatile uint8_t queueDriver; /*!< Index for driver to get the transfer data and size */
|
|
|
|
uint32_t format; /*!< data format */
|
|
uint8_t watermark; /*!< Watermark value */
|
|
uint8_t startChannel; /*!< end channel */
|
|
uint8_t channelNums; /*!< Enabled channel number */
|
|
};
|
|
|
|
/*******************************************************************************
|
|
* API
|
|
******************************************************************************/
|
|
|
|
#if defined(__cplusplus)
|
|
extern "C" {
|
|
#endif /*_cplusplus*/
|
|
|
|
/*!
|
|
* @name Initialization and deinitialization
|
|
* @{
|
|
*/
|
|
|
|
/*!
|
|
* @brief Initializes the PDM peripheral.
|
|
*
|
|
* Ungates the PDM clock, resets the module, and configures PDM with a configuration structure.
|
|
* The configuration structure can be custom filled or set with default values by
|
|
* PDM_GetDefaultConfig().
|
|
*
|
|
* @note This API should be called at the beginning of the application to use
|
|
* the PDM driver. Otherwise, accessing the PDM module can cause a hard fault
|
|
* because the clock is not enabled.
|
|
*
|
|
* @param base PDM base pointer
|
|
* @param config PDM configuration structure.
|
|
*/
|
|
void PDM_Init(PDM_Type *base, const pdm_config_t *config);
|
|
|
|
/*!
|
|
* @brief De-initializes the PDM peripheral.
|
|
*
|
|
* This API gates the PDM clock. The PDM module can't operate unless PDM_Init
|
|
* is called to enable the clock.
|
|
*
|
|
* @param base PDM base pointer
|
|
*/
|
|
void PDM_Deinit(PDM_Type *base);
|
|
|
|
/*!
|
|
* @brief Resets the PDM module.
|
|
*
|
|
* @param base PDM base pointer
|
|
*/
|
|
static inline void PDM_Reset(PDM_Type *base)
|
|
{
|
|
base->CTRL_1 |= PDM_CTRL_1_SRES_MASK;
|
|
}
|
|
|
|
/*!
|
|
* @brief Enables/disables PDM interface.
|
|
*
|
|
* @param base PDM base pointer
|
|
* @param enable True means PDM interface is enabled, false means PDM interface is disabled.
|
|
*/
|
|
static inline void PDM_Enable(PDM_Type *base, bool enable)
|
|
{
|
|
if (enable)
|
|
{
|
|
base->CTRL_1 |= PDM_CTRL_1_PDMIEN_MASK;
|
|
}
|
|
else
|
|
{
|
|
base->CTRL_1 &= ~PDM_CTRL_1_PDMIEN_MASK;
|
|
}
|
|
}
|
|
|
|
/*!
|
|
* @brief Enables/disables DOZE.
|
|
*
|
|
* @param base PDM base pointer
|
|
* @param enable True means the module will enter Disable/Low Leakage mode when ipg_doze is asserted, false means the
|
|
* module will not enter Disable/Low Leakage mode when ipg_doze is asserted.
|
|
*/
|
|
static inline void PDM_EnableDoze(PDM_Type *base, bool enable)
|
|
{
|
|
if (enable)
|
|
{
|
|
base->CTRL_1 |= PDM_CTRL_1_DOZEN_MASK;
|
|
}
|
|
else
|
|
{
|
|
base->CTRL_1 &= ~PDM_CTRL_1_DOZEN_MASK;
|
|
}
|
|
}
|
|
|
|
/*!
|
|
* @brief Enables/disables debug mode for PDM.
|
|
* The PDM interface cannot enter debug mode once in Disable/Low Leakage or Low Power mode.
|
|
* @param base PDM base pointer
|
|
* @param enable True means PDM interface enter debug mode, false means PDM interface in normal mode.
|
|
*/
|
|
static inline void PDM_EnableDebugMode(PDM_Type *base, bool enable)
|
|
{
|
|
if (enable)
|
|
{
|
|
base->CTRL_1 |= PDM_CTRL_1_DBG_MASK;
|
|
}
|
|
else
|
|
{
|
|
base->CTRL_1 &= ~PDM_CTRL_1_DBG_MASK;
|
|
}
|
|
}
|
|
|
|
/*!
|
|
* @brief Enables/disables PDM interface in debug mode.
|
|
*
|
|
* @param base PDM base pointer
|
|
* @param enable True means PDM interface is enabled debug mode, false means PDM interface is disabled after
|
|
* after completing the current frame in debug mode.
|
|
*/
|
|
static inline void PDM_EnableInDebugMode(PDM_Type *base, bool enable)
|
|
{
|
|
if (enable)
|
|
{
|
|
base->CTRL_1 |= PDM_CTRL_1_DBGE_MASK;
|
|
}
|
|
else
|
|
{
|
|
base->CTRL_1 &= ~PDM_CTRL_1_DBGE_MASK;
|
|
}
|
|
}
|
|
|
|
/*!
|
|
* @brief Enables/disables PDM interface disable/Low Leakage mode.
|
|
*
|
|
* @param base PDM base pointer
|
|
* @param enable True means PDM interface is in disable/low leakage mode, False means PDM interface is in normal mode.
|
|
*/
|
|
static inline void PDM_EnterLowLeakageMode(PDM_Type *base, bool enable)
|
|
{
|
|
if (enable)
|
|
{
|
|
base->CTRL_1 |= PDM_CTRL_1_MDIS_MASK;
|
|
}
|
|
else
|
|
{
|
|
base->CTRL_1 &= ~PDM_CTRL_1_MDIS_MASK;
|
|
}
|
|
}
|
|
|
|
/*!
|
|
* @brief Enables/disables the PDM channel.
|
|
*
|
|
* @param base PDM base pointer
|
|
* @param channel PDM channel number need to enable or disable.
|
|
* @param enable True means enable PDM channel, false means disable.
|
|
*/
|
|
static inline void PDM_EnableChannel(PDM_Type *base, uint8_t channel, bool enable)
|
|
{
|
|
if (enable)
|
|
{
|
|
base->CTRL_1 |= (1UL << channel);
|
|
}
|
|
else
|
|
{
|
|
base->CTRL_1 &= ~(1UL << channel);
|
|
}
|
|
}
|
|
|
|
/*!
|
|
* @brief PDM one channel configurations.
|
|
*
|
|
* @param base PDM base pointer
|
|
* @param config PDM channel configurations.
|
|
* @param channel channel number.
|
|
* after completing the current frame in debug mode.
|
|
*/
|
|
void PDM_SetChannelConfig(PDM_Type *base, uint32_t channel, const pdm_channel_config_t *config);
|
|
|
|
/*!
|
|
* @brief PDM set sample rate.
|
|
*
|
|
* @note This function is depend on the configuration of the PDM and PDM channel, so the correct call sequence is
|
|
* @code
|
|
* PDM_Init(base, pdmConfig)
|
|
* PDM_SetChannelConfig(base, channel, &channelConfig)
|
|
* PDM_SetSampleRateConfig(base, source, sampleRate)
|
|
* @endcode
|
|
* @param base PDM base pointer
|
|
* @param sourceClock_HZ PDM source clock frequency.
|
|
* @param sampleRate_HZ PDM sample rate.
|
|
*/
|
|
status_t PDM_SetSampleRateConfig(PDM_Type *base, uint32_t sourceClock_HZ, uint32_t sampleRate_HZ);
|
|
|
|
/*!
|
|
* @brief PDM set sample rate.
|
|
*
|
|
* @deprecated Do not use this function. It has been superceded by @ref PDM_SetSampleRateConfig
|
|
* @param base PDM base pointer
|
|
* @param enableChannelMask PDM channel enable mask.
|
|
* @param qualityMode quality mode.
|
|
* @param osr cic oversample rate
|
|
* @param clkDiv clock divider
|
|
*/
|
|
status_t PDM_SetSampleRate(
|
|
PDM_Type *base, uint32_t enableChannelMask, pdm_df_quality_mode_t qualityMode, uint8_t osr, uint32_t clkDiv);
|
|
|
|
/*!
|
|
* @brief Get the instance number for PDM.
|
|
*
|
|
* @param base PDM base pointer.
|
|
*/
|
|
uint32_t PDM_GetInstance(PDM_Type *base);
|
|
/*! @} */
|
|
|
|
/*!
|
|
* @name Status
|
|
* @{
|
|
*/
|
|
|
|
/*!
|
|
* @brief Gets the PDM internal status flag.
|
|
* Use the Status Mask in _pdm_internal_status to get the status value needed
|
|
* @param base PDM base pointer
|
|
* @return PDM status flag value.
|
|
*/
|
|
static inline uint32_t PDM_GetStatus(PDM_Type *base)
|
|
{
|
|
return base->STAT;
|
|
}
|
|
|
|
/*!
|
|
* @brief Gets the PDM FIFO status flag.
|
|
* Use the Status Mask in _pdm_fifo_status to get the status value needed
|
|
* @param base PDM base pointer
|
|
* @return FIFO status.
|
|
*/
|
|
static inline uint32_t PDM_GetFifoStatus(PDM_Type *base)
|
|
{
|
|
return base->FIFO_STAT;
|
|
}
|
|
|
|
#if defined(FSL_FEATURE_PDM_HAS_RANGE_CTRL) && FSL_FEATURE_PDM_HAS_RANGE_CTRL
|
|
/*!
|
|
* @brief Gets the PDM Range status flag.
|
|
* Use the Status Mask in _pdm_range_status to get the status value needed
|
|
* @param base PDM base pointer
|
|
* @return output status.
|
|
*/
|
|
static inline uint32_t PDM_GetRangeStatus(PDM_Type *base)
|
|
{
|
|
return base->RANGE_STAT;
|
|
}
|
|
#else
|
|
/*!
|
|
* @brief Gets the PDM output status flag.
|
|
* Use the Status Mask in _pdm_output_status to get the status value needed
|
|
* @param base PDM base pointer
|
|
* @return output status.
|
|
*/
|
|
static inline uint32_t PDM_GetOutputStatus(PDM_Type *base)
|
|
{
|
|
return base->OUT_STAT;
|
|
}
|
|
#endif
|
|
|
|
/*!
|
|
* @brief Clears the PDM Tx status.
|
|
*
|
|
* @param base PDM base pointer
|
|
* @param mask State mask. It can be a combination of the status between kPDM_StatusFrequencyLow and
|
|
* kPDM_StatusCh7FifoDataAvaliable.
|
|
*/
|
|
static inline void PDM_ClearStatus(PDM_Type *base, uint32_t mask)
|
|
{
|
|
base->STAT = mask;
|
|
}
|
|
|
|
/*!
|
|
* @brief Clears the PDM Tx status.
|
|
*
|
|
* @param base PDM base pointer
|
|
* @param mask State mask.It can be a combination of the status in _pdm_fifo_status.
|
|
*/
|
|
static inline void PDM_ClearFIFOStatus(PDM_Type *base, uint32_t mask)
|
|
{
|
|
base->FIFO_STAT = mask;
|
|
}
|
|
|
|
#if defined(FSL_FEATURE_PDM_HAS_RANGE_CTRL) && FSL_FEATURE_PDM_HAS_RANGE_CTRL
|
|
/*!
|
|
* @brief Clears the PDM range status.
|
|
*
|
|
* @param base PDM base pointer
|
|
* @param mask State mask. It can be a combination of the status in _pdm_range_status.
|
|
*/
|
|
static inline void PDM_ClearRangeStatus(PDM_Type *base, uint32_t mask)
|
|
{
|
|
base->RANGE_STAT = mask;
|
|
}
|
|
#else
|
|
/*!
|
|
* @brief Clears the PDM output status.
|
|
*
|
|
* @param base PDM base pointer
|
|
* @param mask State mask. It can be a combination of the status in _pdm_output_status.
|
|
*/
|
|
static inline void PDM_ClearOutputStatus(PDM_Type *base, uint32_t mask)
|
|
{
|
|
base->OUT_STAT = mask;
|
|
}
|
|
#endif
|
|
|
|
/*! @} */
|
|
|
|
/*!
|
|
* @name Interrupts
|
|
* @{
|
|
*/
|
|
|
|
/*!
|
|
* @brief Enables the PDM interrupt requests.
|
|
*
|
|
* @param base PDM base pointer
|
|
* @param mask interrupt source
|
|
* The parameter can be a combination of the following sources if defined.
|
|
* @arg kPDM_ErrorInterruptEnable
|
|
* @arg kPDM_FIFOInterruptEnable
|
|
*/
|
|
void PDM_EnableInterrupts(PDM_Type *base, uint32_t mask);
|
|
|
|
/*!
|
|
* @brief Disables the PDM interrupt requests.
|
|
*
|
|
* @param base PDM base pointer
|
|
* @param mask interrupt source
|
|
* The parameter can be a combination of the following sources if defined.
|
|
* @arg kPDM_ErrorInterruptEnable
|
|
* @arg kPDM_FIFOInterruptEnable
|
|
*/
|
|
static inline void PDM_DisableInterrupts(PDM_Type *base, uint32_t mask)
|
|
{
|
|
base->CTRL_1 &= ~mask;
|
|
}
|
|
|
|
/*! @} */
|
|
|
|
/*!
|
|
* @name DMA Control
|
|
* @{
|
|
*/
|
|
|
|
/*!
|
|
* @brief Enables/disables the PDM DMA requests.
|
|
*
|
|
* @param base PDM base pointer
|
|
* @param enable True means enable DMA, false means disable DMA.
|
|
*/
|
|
static inline void PDM_EnableDMA(PDM_Type *base, bool enable)
|
|
{
|
|
if (enable)
|
|
{
|
|
base->CTRL_1 = (base->CTRL_1 & (~PDM_CTRL_1_DISEL_MASK)) | PDM_CTRL_1_DISEL(0x1U);
|
|
}
|
|
else
|
|
{
|
|
base->CTRL_1 &= ~PDM_CTRL_1_DISEL_MASK;
|
|
}
|
|
}
|
|
|
|
/*!
|
|
* @brief Gets the PDM data register address.
|
|
*
|
|
* This API is used to provide a transfer address for the PDM DMA transfer configuration.
|
|
*
|
|
* @param base PDM base pointer.
|
|
* @param channel Which data channel used.
|
|
* @return data register address.
|
|
*/
|
|
static inline uint32_t PDM_GetDataRegisterAddress(PDM_Type *base, uint32_t channel)
|
|
{
|
|
return (uint32_t)(&(base->DATACH)[channel]);
|
|
}
|
|
|
|
/*! @} */
|
|
|
|
/*!
|
|
* @name Bus Operations
|
|
* @{
|
|
*/
|
|
#if defined(FSL_FEATURE_PDM_FIFO_WIDTH) && (FSL_FEATURE_PDM_FIFO_WIDTH == 2U)
|
|
/*!
|
|
* @brief Reads data from the PDM FIFO.
|
|
*
|
|
* @param base PDM base pointer.
|
|
* @param channel Data channel used.
|
|
* @return Data in PDM FIFO.
|
|
*/
|
|
static inline int16_t PDM_ReadData(PDM_Type *base, uint32_t channel)
|
|
{
|
|
return (int16_t)(base->DATACH[channel]);
|
|
}
|
|
|
|
/*!
|
|
* @brief PDM read data non blocking.
|
|
* So the actually read data byte size in this function is (size * 2 * channelNums).
|
|
* @param base PDM base pointer.
|
|
* @param startChannel start channel number.
|
|
* @param channelNums total enabled channelnums.
|
|
* @param buffer received buffer address.
|
|
* @param size number of 16bit data to read.
|
|
*/
|
|
void PDM_ReadNonBlocking(PDM_Type *base, uint32_t startChannel, uint32_t channelNums, int16_t *buffer, size_t size);
|
|
#endif
|
|
|
|
/*!
|
|
* @brief PDM read fifo.
|
|
* @note: This function support 16 bit only for IP version that only supports 16bit.
|
|
*
|
|
* @param base PDM base pointer.
|
|
* @param startChannel start channel number.
|
|
* @param channelNums total enabled channelnums.
|
|
* @param buffer received buffer address.
|
|
* @param size number of samples to read.
|
|
* @param dataWidth sample width.
|
|
*/
|
|
void PDM_ReadFifo(
|
|
PDM_Type *base, uint32_t startChannel, uint32_t channelNums, void *buffer, size_t size, uint32_t dataWidth);
|
|
|
|
#if defined(FSL_FEATURE_PDM_FIFO_WIDTH) && (FSL_FEATURE_PDM_FIFO_WIDTH == 4U)
|
|
/*!
|
|
* @brief Reads data from the PDM FIFO.
|
|
*
|
|
* @param base PDM base pointer.
|
|
* @param channel Data channel used.
|
|
* @return Data in PDM FIFO.
|
|
*/
|
|
static inline uint32_t PDM_ReadData(PDM_Type *base, uint32_t channel)
|
|
{
|
|
return base->DATACH[channel];
|
|
}
|
|
#endif
|
|
|
|
/*!
|
|
* @brief Set the PDM channel gain.
|
|
*
|
|
* Please note for different quality mode, the valid gain value is different, reference RM for detail.
|
|
* @param base PDM base pointer.
|
|
* @param channel PDM channel index.
|
|
* @param gain channel gain, the register gain value range is 0 - 15.
|
|
*/
|
|
void PDM_SetChannelGain(PDM_Type *base, uint32_t channel, pdm_df_output_gain_t gain);
|
|
|
|
/*! @} */
|
|
|
|
/*!
|
|
* @name Voice Activity Detector
|
|
* @{
|
|
*/
|
|
|
|
/*!
|
|
* @brief Configure voice activity detector.
|
|
*
|
|
* @param base PDM base pointer
|
|
* @param config Voice activity detector configure structure pointer .
|
|
*/
|
|
void PDM_SetHwvadConfig(PDM_Type *base, const pdm_hwvad_config_t *config);
|
|
|
|
/*!
|
|
* @brief PDM hwvad force output disable.
|
|
*
|
|
* @param base PDM base pointer
|
|
* @param enable true is output force disable, false is output not force.
|
|
*/
|
|
static inline void PDM_ForceHwvadOutputDisable(PDM_Type *base, bool enable)
|
|
{
|
|
if (enable)
|
|
{
|
|
base->VAD0_CTRL_2 &= ~PDM_VAD0_CTRL_2_VADFOUTDIS_MASK;
|
|
}
|
|
else
|
|
{
|
|
base->VAD0_CTRL_2 |= PDM_VAD0_CTRL_2_VADFOUTDIS_MASK;
|
|
}
|
|
}
|
|
|
|
/*!
|
|
* @brief PDM hwvad reset.
|
|
* It will reset VADNDATA register and will clean all internal buffers, should be called when the PDM isn't running.
|
|
*
|
|
* @param base PDM base pointer
|
|
*/
|
|
static inline void PDM_ResetHwvad(PDM_Type *base)
|
|
{
|
|
base->VAD0_CTRL_1 |= PDM_VAD0_CTRL_1_VADRST_MASK;
|
|
}
|
|
/*!
|
|
* @brief Enable/Disable Voice activity detector.
|
|
* Should be called when the PDM isn't running.
|
|
* @param base PDM base pointer.
|
|
* @param enable True means enable voice activity detector, false means disable.
|
|
*/
|
|
static inline void PDM_EnableHwvad(PDM_Type *base, bool enable)
|
|
{
|
|
if (enable)
|
|
{
|
|
base->VAD0_CTRL_1 |= PDM_VAD0_CTRL_1_VADEN_MASK;
|
|
}
|
|
else
|
|
{
|
|
base->VAD0_CTRL_1 &= ~PDM_VAD0_CTRL_1_VADEN_MASK;
|
|
}
|
|
}
|
|
|
|
/*!
|
|
* @brief Enables the PDM Voice Detector interrupt requests.
|
|
*
|
|
* @param base PDM base pointer
|
|
* @param mask interrupt source
|
|
* The parameter can be a combination of the following sources if defined.
|
|
* @arg kPDM_HWVADErrorInterruptEnable
|
|
* @arg kPDM_HWVADInterruptEnable
|
|
*/
|
|
static inline void PDM_EnableHwvadInterrupts(PDM_Type *base, uint32_t mask)
|
|
{
|
|
base->VAD0_CTRL_1 |= mask;
|
|
}
|
|
|
|
/*!
|
|
* @brief Disables the PDM Voice Detector interrupt requests.
|
|
*
|
|
* @param base PDM base pointer
|
|
* @param mask interrupt source
|
|
* The parameter can be a combination of the following sources if defined.
|
|
* @arg kPDM_HWVADErrorInterruptEnable
|
|
* @arg kPDM_HWVADInterruptEnable
|
|
*/
|
|
static inline void PDM_DisableHwvadInterrupts(PDM_Type *base, uint32_t mask)
|
|
{
|
|
base->VAD0_CTRL_1 &= ~mask;
|
|
}
|
|
|
|
/*!
|
|
* @brief Clears the PDM voice activity detector status flags.
|
|
*
|
|
* @param base PDM base pointer
|
|
* @param mask State mask,reference _pdm_hwvad_int_status.
|
|
*/
|
|
static inline void PDM_ClearHwvadInterruptStatusFlags(PDM_Type *base, uint32_t mask)
|
|
{
|
|
base->VAD0_STAT = mask;
|
|
}
|
|
|
|
/*!
|
|
* @brief Clears the PDM voice activity detector status flags.
|
|
*
|
|
* @param base PDM base pointer
|
|
* @return status, reference _pdm_hwvad_int_status
|
|
*/
|
|
static inline uint32_t PDM_GetHwvadInterruptStatusFlags(PDM_Type *base)
|
|
{
|
|
return base->VAD0_STAT & (PDM_VAD0_STAT_VADIF_MASK | PDM_VAD0_STAT_VADINSATF_MASK);
|
|
}
|
|
|
|
/*!
|
|
* @brief Get the PDM voice activity detector initial flags.
|
|
*
|
|
* @param base PDM base pointer
|
|
* @return initial flag.
|
|
*/
|
|
static inline uint32_t PDM_GetHwvadInitialFlag(PDM_Type *base)
|
|
{
|
|
return base->VAD0_STAT & PDM_VAD0_STAT_VADINITF_MASK;
|
|
}
|
|
|
|
/*!
|
|
* @brief Get the PDM voice activity detector voice detected flags.
|
|
* NOte: this flag is auto cleared when voice gone.
|
|
* @param base PDM base pointer
|
|
* @return voice detected flag.
|
|
*/
|
|
static inline uint32_t PDM_GetHwvadVoiceDetectedFlag(PDM_Type *base)
|
|
{
|
|
return base->VAD0_STAT & PDM_VAD0_STAT_VADEF_MASK;
|
|
}
|
|
|
|
/*!
|
|
* @brief Enables/disables voice activity detector signal filter.
|
|
*
|
|
* @param base PDM base pointer
|
|
* @param enable True means enable signal filter, false means disable.
|
|
*/
|
|
static inline void PDM_EnableHwvadSignalFilter(PDM_Type *base, bool enable)
|
|
{
|
|
if (enable)
|
|
{
|
|
base->VAD0_SCONFIG |= PDM_VAD0_SCONFIG_VADSFILEN_MASK;
|
|
}
|
|
else
|
|
{
|
|
base->VAD0_SCONFIG &= ~PDM_VAD0_SCONFIG_VADSFILEN_MASK;
|
|
}
|
|
}
|
|
|
|
/*!
|
|
* @brief Configure voice activity detector signal filter.
|
|
*
|
|
* @param base PDM base pointer
|
|
* @param enableMaxBlock If signal maximum block enabled.
|
|
* @param signalGain Gain value for the signal energy.
|
|
*/
|
|
void PDM_SetHwvadSignalFilterConfig(PDM_Type *base, bool enableMaxBlock, uint32_t signalGain);
|
|
|
|
/*!
|
|
* @brief Configure voice activity detector noise filter.
|
|
*
|
|
* @param base PDM base pointer
|
|
* @param config Voice activity detector noise filter configure structure pointer .
|
|
*/
|
|
void PDM_SetHwvadNoiseFilterConfig(PDM_Type *base, const pdm_hwvad_noise_filter_t *config);
|
|
|
|
/*!
|
|
* @brief Enables/disables voice activity detector zero cross detector.
|
|
*
|
|
* @param base PDM base pointer
|
|
* @param enable True means enable zero cross detector, false means disable.
|
|
*/
|
|
static inline void PDM_EnableHwvadZeroCrossDetector(PDM_Type *base, bool enable)
|
|
{
|
|
if (enable)
|
|
{
|
|
base->VAD0_ZCD |= PDM_VAD0_ZCD_VADZCDEN_MASK;
|
|
}
|
|
else
|
|
{
|
|
base->VAD0_ZCD &= ~PDM_VAD0_ZCD_VADZCDEN_MASK;
|
|
}
|
|
}
|
|
|
|
/*!
|
|
* @brief Configure voice activity detector zero cross detector.
|
|
*
|
|
* @param base PDM base pointer
|
|
* @param config Voice activity detector zero cross detector configure structure pointer .
|
|
*/
|
|
void PDM_SetHwvadZeroCrossDetectorConfig(PDM_Type *base, const pdm_hwvad_zero_cross_detector_t *config);
|
|
|
|
/*!
|
|
* @brief Reads noise data.
|
|
*
|
|
* @param base PDM base pointer.
|
|
* @return Data in PDM noise data register.
|
|
*/
|
|
static inline uint16_t PDM_GetNoiseData(PDM_Type *base)
|
|
{
|
|
return (uint16_t)base->VAD0_NDATA;
|
|
}
|
|
|
|
/*!
|
|
* @brief set hwvad internal filter status .
|
|
* Note: filter initial status should be asserted for two more cycles, then set it to normal operation.
|
|
* @param base PDM base pointer.
|
|
* @param status internal filter status.
|
|
*/
|
|
static inline void PDM_SetHwvadInternalFilterStatus(PDM_Type *base, pdm_hwvad_filter_status_t status)
|
|
{
|
|
base->VAD0_CTRL_1 = (base->VAD0_CTRL_1 & (~PDM_VAD0_CTRL_1_VADST10_MASK)) | (uint32_t)status;
|
|
}
|
|
|
|
/*!
|
|
* @brief set HWVAD in envelope based mode .
|
|
* Recommand configurations,
|
|
* @code
|
|
* static const pdm_hwvad_config_t hwvadConfig = {
|
|
* .channel = 0,
|
|
* .initializeTime = 10U,
|
|
* .cicOverSampleRate = 0U,
|
|
* .inputGain = 0U,
|
|
* .frameTime = 10U,
|
|
* .cutOffFreq = kPDM_HwvadHpfBypassed,
|
|
* .enableFrameEnergy = false,
|
|
* .enablePreFilter = true,
|
|
};
|
|
|
|
* static const pdm_hwvad_noise_filter_t noiseFilterConfig = {
|
|
* .enableAutoNoiseFilter = false,
|
|
* .enableNoiseMin = true,
|
|
* .enableNoiseDecimation = true,
|
|
* .noiseFilterAdjustment = 0U,
|
|
* .noiseGain = 7U,
|
|
* .enableNoiseDetectOR = true,
|
|
* };
|
|
* @endcode
|
|
* @param base PDM base pointer.
|
|
* @param hwvadConfig internal filter status.
|
|
* @param noiseConfig Voice activity detector noise filter configure structure pointer.
|
|
* @param zcdConfig Voice activity detector zero cross detector configure structure pointer .
|
|
* @param signalGain signal gain value.
|
|
*/
|
|
void PDM_SetHwvadInEnvelopeBasedMode(PDM_Type *base,
|
|
const pdm_hwvad_config_t *hwvadConfig,
|
|
const pdm_hwvad_noise_filter_t *noiseConfig,
|
|
const pdm_hwvad_zero_cross_detector_t *zcdConfig,
|
|
uint32_t signalGain);
|
|
|
|
/*!
|
|
* brief set HWVAD in energy based mode .
|
|
* Recommand configurations,
|
|
* code
|
|
* static const pdm_hwvad_config_t hwvadConfig = {
|
|
* .channel = 0,
|
|
* .initializeTime = 10U,
|
|
* .cicOverSampleRate = 0U,
|
|
* .inputGain = 0U,
|
|
* .frameTime = 10U,
|
|
* .cutOffFreq = kPDM_HwvadHpfBypassed,
|
|
* .enableFrameEnergy = true,
|
|
* .enablePreFilter = true,
|
|
};
|
|
|
|
* static const pdm_hwvad_noise_filter_t noiseFilterConfig = {
|
|
* .enableAutoNoiseFilter = true,
|
|
* .enableNoiseMin = false,
|
|
* .enableNoiseDecimation = false,
|
|
* .noiseFilterAdjustment = 0U,
|
|
* .noiseGain = 7U,
|
|
* .enableNoiseDetectOR = false,
|
|
* };
|
|
* code
|
|
* param base PDM base pointer.
|
|
* param hwvadConfig internal filter status.
|
|
* param noiseConfig Voice activity detector noise filter configure structure pointer.
|
|
* param zcdConfig Voice activity detector zero cross detector configure structure pointer .
|
|
* param signalGain signal gain value, signal gain value should be properly according to application.
|
|
*/
|
|
void PDM_SetHwvadInEnergyBasedMode(PDM_Type *base,
|
|
const pdm_hwvad_config_t *hwvadConfig,
|
|
const pdm_hwvad_noise_filter_t *noiseConfig,
|
|
const pdm_hwvad_zero_cross_detector_t *zcdConfig,
|
|
uint32_t signalGain);
|
|
|
|
/*!
|
|
* @brief Enable/Disable hwvad callback.
|
|
|
|
* This function enable/disable the hwvad interrupt for the selected PDM peripheral.
|
|
*
|
|
* @param base Base address of the PDM peripheral.
|
|
* @param vadCallback callback Pointer to store callback function, should be NULL when disable.
|
|
* @param userData user data.
|
|
* @param enable true is enable, false is disable.
|
|
* @retval None.
|
|
*/
|
|
void PDM_EnableHwvadInterruptCallback(PDM_Type *base, pdm_hwvad_callback_t vadCallback, void *userData, bool enable);
|
|
/*! @} */
|
|
|
|
/*!
|
|
* @name Transactional
|
|
* @{
|
|
*/
|
|
|
|
/*!
|
|
* @brief Initializes the PDM handle.
|
|
*
|
|
* This function initializes the handle for the PDM transactional APIs. Call
|
|
* this function once to get the handle initialized.
|
|
*
|
|
* @param base PDM base pointer.
|
|
* @param handle PDM handle pointer.
|
|
* @param callback Pointer to the user callback function.
|
|
* @param userData User parameter passed to the callback function.
|
|
*/
|
|
void PDM_TransferCreateHandle(PDM_Type *base, pdm_handle_t *handle, pdm_transfer_callback_t callback, void *userData);
|
|
|
|
/*!
|
|
* @brief PDM set channel transfer config.
|
|
*
|
|
* @param base PDM base pointer.
|
|
* @param handle PDM handle pointer.
|
|
* @param channel PDM channel.
|
|
* @param config channel config.
|
|
* @param format data format, support data width configurations,_pdm_data_width.
|
|
* @retval kStatus_PDM_ChannelConfig_Failed or kStatus_Success.
|
|
*/
|
|
status_t PDM_TransferSetChannelConfig(
|
|
PDM_Type *base, pdm_handle_t *handle, uint32_t channel, const pdm_channel_config_t *config, uint32_t format);
|
|
|
|
/*!
|
|
* @brief Performs an interrupt non-blocking receive transfer on PDM.
|
|
*
|
|
* @note This API returns immediately after the transfer initiates.
|
|
* Call the PDM_RxGetTransferStatusIRQ to poll the transfer status and check whether
|
|
* the transfer is finished. If the return status is not kStatus_PDM_Busy, the transfer
|
|
* is finished.
|
|
*
|
|
* @param base PDM base pointer
|
|
* @param handle Pointer to the pdm_handle_t structure which stores the transfer state.
|
|
* @param xfer Pointer to the pdm_transfer_t structure.
|
|
* @retval kStatus_Success Successfully started the data receive.
|
|
* @retval kStatus_PDM_Busy Previous receive still not finished.
|
|
*/
|
|
status_t PDM_TransferReceiveNonBlocking(PDM_Type *base, pdm_handle_t *handle, pdm_transfer_t *xfer);
|
|
|
|
/*!
|
|
* @brief Aborts the current IRQ receive.
|
|
*
|
|
* @note This API can be called when an interrupt non-blocking transfer initiates
|
|
* to abort the transfer early.
|
|
*
|
|
* @param base PDM base pointer
|
|
* @param handle Pointer to the pdm_handle_t structure which stores the transfer state.
|
|
*/
|
|
void PDM_TransferAbortReceive(PDM_Type *base, pdm_handle_t *handle);
|
|
|
|
/*!
|
|
* @brief Tx interrupt handler.
|
|
*
|
|
* @param base PDM base pointer.
|
|
* @param handle Pointer to the pdm_handle_t structure.
|
|
*/
|
|
void PDM_TransferHandleIRQ(PDM_Type *base, pdm_handle_t *handle);
|
|
|
|
/*! @} */
|
|
|
|
#if defined(__cplusplus)
|
|
}
|
|
#endif /*_cplusplus*/
|
|
|
|
/*! @} */
|
|
|
|
#endif /* _FSL_PDM_H_ */
|