ARMmbed
/
mbed-os
mirror of https://github.com/ARMmbed/mbed-os.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Merge pull request #10605 from sabharad/master 

K66F: Update SAI and SAI EDMA driver to SDK 2.5
pull/10627/head
Martin Kojtal 2019-05-21 10:51:28 +01:00 committed by GitHub
parent 7d0cc69fb1 0897f6c196
commit e4c64226f6
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
4 changed files with 2426 additions and 203 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1941
targets/TARGET_Freescale/TARGET_MCUXpresso_MCUS/TARGET_K66F/drivers/fsl_sai.c
View File

File diff suppressed because it is too large Load Diff

337
targets/TARGET_Freescale/TARGET_MCUXpresso_MCUS/TARGET_K66F/drivers/fsl_sai.h
View File

@ -1,31 +1,9 @@
/*
* Copyright (c) 2015, Freescale Semiconductor, Inc.
* Copyright 2016-2017 NXP
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* o Redistributions of source code must retain the above copyright notice, this list
* of conditions and the following disclaimer.
*
* o Redistributions in binary form must reproduce the above copyright notice, this
* list of conditions and the following disclaimer in the documentation and/or
* other materials provided with the distribution.
*
* o Neither the name of the copyright holder nor the names of its
* contributors may be used to endorse or promote products derived from this
* software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
* ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* SPDX-License-Identifier: BSD-3-Clause
*/
#ifndef _FSL_SAI_H_
@ -44,7 +22,7 @@
/*! @name Driver version */
/*@{*/
#define FSL_SAI_DRIVER_VERSION (MAKE_VERSION(2, 1, 2)) /*!< Version 2.1.2 */
#define FSL_SAI_DRIVER_VERSION (MAKE_VERSION(2, 1, 7)) /*!< Version 2.1.7 */
/*@}*/
/*! @brief SAI return status*/
@ -59,6 +37,19 @@ enum _sai_status_t
kStatus_SAI_RxIdle = MAKE_STATUS(kStatusGroup_SAI, 6) /*!< SAI Rx is idle */
};
/*< sai channel mask value, actual channel numbers is depend soc specific */
enum _sai_channel_mask
{
kSAI_Channel0Mask = 1 << 0U, /*!< channel 0 mask value */
kSAI_Channel1Mask = 1 << 1U, /*!< channel 1 mask value */
kSAI_Channel2Mask = 1 << 2U, /*!< channel 2 mask value */
kSAI_Channel3Mask = 1 << 3U, /*!< channel 3 mask value */
kSAI_Channel4Mask = 1 << 4U, /*!< channel 4 mask value */
kSAI_Channel5Mask = 1 << 5U, /*!< channel 5 mask value */
kSAI_Channel6Mask = 1 << 6U, /*!< channel 6 mask value */
kSAI_Channel7Mask = 1 << 7U, /*!< channel 7 mask value */
};
/*! @brief Define the SAI bus type */
typedef enum _sai_protocol
{
@ -80,10 +71,24 @@ typedef enum _sai_master_slave
typedef enum _sai_mono_stereo
{
kSAI_Stereo = 0x0U, /*!< Stereo sound. */
kSAI_MonoLeft, /*!< Only left channel have sound. */
kSAI_MonoRight /*!< Only Right channel have sound. */
kSAI_MonoRight, /*!< Only Right channel have sound. */
kSAI_MonoLeft /*!< Only left channel have sound. */
} sai_mono_stereo_t;
/*! @brief SAI data order, MSB or LSB */
typedef enum _sai_data_order
{
kSAI_DataLSB = 0x0U, /*!< LSB bit transferred first */
kSAI_DataMSB /*!< MSB bit transferred first */
} sai_data_order_t;
/*! @brief SAI clock polarity, active high or low */
typedef enum _sai_clock_polarity
{
kSAI_PolarityActiveHigh = 0x0U, /*!< Clock active high */
kSAI_PolarityActiveLow /*!< Clock active low */
} sai_clock_polarity_t;
/*! @brief Synchronous or asynchronous mode */
typedef enum _sai_sync_mode
{
@ -93,6 +98,7 @@ typedef enum _sai_sync_mode
kSAI_ModeSyncWithOtherRx /*!< Synchronous with another SAI receiver */
} sai_sync_mode_t;
#if !(defined(FSL_FEATURE_SAI_HAS_NO_MCR_MICS) && (FSL_FEATURE_SAI_HAS_NO_MCR_MICS))
/*! @brief Mater clock source */
typedef enum _sai_mclk_source
{
@ -101,14 +107,20 @@ typedef enum _sai_mclk_source
kSAI_MclkSourceSelect2, /*!< Master clock from source 2 */
kSAI_MclkSourceSelect3 /*!< Master clock from source 3 */
} sai_mclk_source_t;
#endif
/*! @brief Bit clock source */
typedef enum _sai_bclk_source
{
kSAI_BclkSourceBusclk = 0x0U, /*!< Bit clock using bus clock */
kSAI_BclkSourceMclkDiv, /*!< Bit clock using master clock divider */
kSAI_BclkSourceOtherSai0, /*!< Bit clock from other SAI device */
kSAI_BclkSourceOtherSai1 /*!< Bit clock from other SAI device */
/* General device bit source definition */
kSAI_BclkSourceMclkOption1 = 0x1U, /*!< Bit clock MCLK option 1 */
kSAI_BclkSourceMclkOption2 = 0x2U, /*!< Bit clock MCLK option2 */
kSAI_BclkSourceMclkOption3 = 0x3U, /*!< Bit clock MCLK option3 */
/* Kinetis device bit clock source definition */
kSAI_BclkSourceMclkDiv = 0x1U, /*!< Bit clock using master clock divider */
kSAI_BclkSourceOtherSai0 = 0x2U, /*!< Bit clock from other SAI device */
kSAI_BclkSourceOtherSai1 = 0x3U /*!< Bit clock from other SAI device */
} sai_bclk_source_t;
/*! @brief The SAI interrupt enable flag */
@ -172,9 +184,11 @@ typedef struct _sai_config
sai_protocol_t protocol; /*!< Audio bus protocol in SAI */
sai_sync_mode_t syncMode; /*!< SAI sync mode, control Tx/Rx clock sync */
#if defined(FSL_FEATURE_SAI_HAS_MCR) && (FSL_FEATURE_SAI_HAS_MCR)
bool mclkOutputEnable; /*!< Master clock output enable, true means master clock divider enabled */
#endif /* FSL_FEATURE_SAI_HAS_MCR */
sai_mclk_source_t mclkSource; /*!< Master Clock source */
bool mclkOutputEnable; /*!< Master clock output enable, true means master clock divider enabled */
#if !(defined(FSL_FEATURE_SAI_HAS_NO_MCR_MICS) && (FSL_FEATURE_SAI_HAS_NO_MCR_MICS))
sai_mclk_source_t mclkSource; /*!< Master Clock source */
#endif /* FSL_FEATURE_SAI_HAS_MCR */
#endif
sai_bclk_source_t bclkSource; /*!< Bit Clock source */
sai_master_slave_t masterSlave; /*!< Master or slave */
} sai_config_t;
@ -194,7 +208,9 @@ typedef enum _sai_sample_rate
kSAI_SampleRate32KHz = 32000U, /*!< Sample rate 32000 Hz */
kSAI_SampleRate44100Hz = 44100U, /*!< Sample rate 44100 Hz */
kSAI_SampleRate48KHz = 48000U, /*!< Sample rate 48000 Hz */
kSAI_SampleRate96KHz = 96000U /*!< Sample rate 96000 Hz */
kSAI_SampleRate96KHz = 96000U, /*!< Sample rate 96000 Hz */
kSAI_SampleRate192KHz = 192000U, /*!< Sample rate 192000 Hz */
kSAI_SampleRate384KHz = 384000U, /*!< Sample rate 384000 Hz */
} sai_sample_rate_t;
/*! @brief Audio word width */
@ -214,10 +230,24 @@ typedef struct _sai_transfer_format
sai_mono_stereo_t stereo; /*!< Mono or stereo */
uint32_t masterClockHz; /*!< Master clock frequency in Hz */
#if defined(FSL_FEATURE_SAI_FIFO_COUNT) && (FSL_FEATURE_SAI_FIFO_COUNT > 1)
uint8_t watermark; /*!< Watermark value */
#endif /* FSL_FEATURE_SAI_FIFO_COUNT */
uint8_t channel; /*!< Data channel used in transfer.*/
uint8_t watermark; /*!< Watermark value */
#endif /* FSL_FEATURE_SAI_FIFO_COUNT */
/* for the multi channel usage, user can provide channelMask Oonly, then sai driver will handle
* other parameter carefully, such as
* channelMask = kSAI_Channel0Mask | kSAI_Channel1Mask | kSAI_Channel4Mask
* then in SAI_RxSetFormat/SAI_TxSetFormat function, channel/endChannel/channelNums will be calculated.
* for the single channel usage, user can provide channel or channel mask only, such as,
* channel = 0 or channelMask = kSAI_Channel0Mask.
*/
uint8_t channel; /*!< Transfer start channel */
uint8_t channelMask; /*!< enabled channel mask value, reference _sai_channel_mask */
uint8_t endChannel; /*!< end channel number */
uint8_t channelNums; /*!< Total enabled channel numbers */
sai_protocol_t protocol; /*!< Which audio protocol used */
bool isFrameSyncCompact; /*!< True means Frame sync length is configurable according to bitWidth, false means frame
sync length is 64 times of bit clock. */
} sai_transfer_format_t;
/*! @brief SAI transfer structure */
@ -235,11 +265,25 @@ typedef void (*sai_transfer_callback_t)(I2S_Type *base, sai_handle_t *handle, st
/*! @brief SAI handle structure */
struct _sai_handle
{
uint32_t state; /*!< Transfer status */
sai_transfer_callback_t callback; /*!< Callback function called at transfer event*/
void *userData; /*!< Callback parameter passed to callback function*/
uint8_t bitWidth; /*!< Bit width for transfer, 8/16/24/32 bits */
uint8_t channel; /*!< Transfer channel */
I2S_Type *base; /*!< base address */
uint32_t state; /*!< Transfer status */
sai_transfer_callback_t callback; /*!< Callback function called at transfer event*/
void *userData; /*!< Callback parameter passed to callback function*/
uint8_t bitWidth; /*!< Bit width for transfer, 8/16/24/32 bits */
/* for the multi channel usage, user can provide channelMask Oonly, then sai driver will handle
* other parameter carefully, such as
* channelMask = kSAI_Channel0Mask | kSAI_Channel1Mask | kSAI_Channel4Mask
* then in SAI_RxSetFormat/SAI_TxSetFormat function, channel/endChannel/channelNums will be calculated.
* for the single channel usage, user can provide channel or channel mask only, such as,
* channel = 0 or channelMask = kSAI_Channel0Mask.
*/
uint8_t channel; /*!< Transfer start channel */
uint8_t channelMask; /*!< enabled channel mask value, refernece _sai_channel_mask */
uint8_t endChannel; /*!< end channel number */
uint8_t channelNums; /*!< Total enabled channel numbers */
sai_transfer_t saiQueue[SAI_XFER_QUEUE_SIZE]; /*!< Transfer queue storing queued transfer */
size_t transferSize[SAI_XFER_QUEUE_SIZE]; /*!< Data bytes need to transfer */
volatile uint8_t queueUser; /*!< Index for user to queue transfer */
@ -279,7 +323,7 @@ extern "C" {
void SAI_TxInit(I2S_Type *base, const sai_config_t *config);
/*!
* @brief Initializes the the SAI Rx peripheral.
* @brief Initializes the SAI Rx peripheral.
*
* Ungates the SAI clock, resets the module, and configures the SAI Rx with a configuration structure.
* The configuration structure can be custom filled or set with default values by
@ -427,6 +471,159 @@ static inline void SAI_RxClearStatusFlags(I2S_Type *base, uint32_t mask)
base->RCSR = ((base->RCSR & 0xFFE3FFFFU) | mask);
}
/*!
* @brief Do software reset or FIFO reset .
*
* FIFO reset means clear all the data in the FIFO, and make the FIFO pointer both to 0.
* Software reset means claer the Tx internal logic, including the bit clock, frame count etc. But software
* reset will not clear any configuration registers like TCR1~TCR5.
* This function will also clear all the error flags such as FIFO error, sync error etc.
*
* @param base SAI base pointer
* @param type Reset type, FIFO reset or software reset
*/
void SAI_TxSoftwareReset(I2S_Type *base, sai_reset_type_t type);
/*!
* @brief Do software reset or FIFO reset .
*
* FIFO reset means clear all the data in the FIFO, and make the FIFO pointer both to 0.
* Software reset means claer the Rx internal logic, including the bit clock, frame count etc. But software
* reset will not clear any configuration registers like RCR1~RCR5.
* This function will also clear all the error flags such as FIFO error, sync error etc.
*
* @param base SAI base pointer
* @param type Reset type, FIFO reset or software reset
*/
void SAI_RxSoftwareReset(I2S_Type *base, sai_reset_type_t type);
/*!
* @brief Set the Tx channel FIFO enable mask.
*
* @param base SAI base pointer
* @param mask Channel enable mask, 0 means all channel FIFO disabled, 1 means channel 0 enabled,
* 3 means both channel 0 and channel 1 enabled.
*/
void SAI_TxSetChannelFIFOMask(I2S_Type *base, uint8_t mask);
/*!
* @brief Set the Rx channel FIFO enable mask.
*
* @param base SAI base pointer
* @param mask Channel enable mask, 0 means all channel FIFO disabled, 1 means channel 0 enabled,
* 3 means both channel 0 and channel 1 enabled.
*/
void SAI_RxSetChannelFIFOMask(I2S_Type *base, uint8_t mask);
/*!
* @brief Set the Tx data order.
*
* @param base SAI base pointer
* @param order Data order MSB or LSB
*/
void SAI_TxSetDataOrder(I2S_Type *base, sai_data_order_t order);
/*!
* @brief Set the Rx data order.
*
* @param base SAI base pointer
* @param order Data order MSB or LSB
*/
void SAI_RxSetDataOrder(I2S_Type *base, sai_data_order_t order);
/*!
* @brief Set the Tx data order.
*
* @param base SAI base pointer
* @param order Data order MSB or LSB
*/
void SAI_TxSetBitClockPolarity(I2S_Type *base, sai_clock_polarity_t polarity);
/*!
* @brief Set the Rx data order.
*
* @param base SAI base pointer
* @param order Data order MSB or LSB
*/
void SAI_RxSetBitClockPolarity(I2S_Type *base, sai_clock_polarity_t polarity);
/*!
* @brief Set the Tx data order.
*
* @param base SAI base pointer
* @param order Data order MSB or LSB
*/
void SAI_TxSetFrameSyncPolarity(I2S_Type *base, sai_clock_polarity_t polarity);
/*!
* @brief Set the Rx data order.
*
* @param base SAI base pointer
* @param order Data order MSB or LSB
*/
void SAI_RxSetFrameSyncPolarity(I2S_Type *base, sai_clock_polarity_t polarity);
#if defined(FSL_FEATURE_SAI_HAS_FIFO_PACKING) && FSL_FEATURE_SAI_HAS_FIFO_PACKING
/*!
* @brief Set Tx FIFO packing feature.
*
* @param base SAI base pointer.
* @param pack FIFO pack type. It is element of sai_fifo_packing_t.
*/
void SAI_TxSetFIFOPacking(I2S_Type *base, sai_fifo_packing_t pack);
/*!
* @brief Set Rx FIFO packing feature.
*
* @param base SAI base pointer.
* @param pack FIFO pack type. It is element of sai_fifo_packing_t.
*/
void SAI_RxSetFIFOPacking(I2S_Type *base, sai_fifo_packing_t pack);
#endif /* FSL_FEATURE_SAI_HAS_FIFO_PACKING */
#if defined(FSL_FEATURE_SAI_HAS_FIFO_FUNCTION_AFTER_ERROR) && FSL_FEATURE_SAI_HAS_FIFO_FUNCTION_AFTER_ERROR
/*!
* @brief Set Tx FIFO error continue.
*
* FIFO error continue mode means SAI will keep running while FIFO error occured. If this feature
* not enabled, SAI will hang and users need to clear FEF flag in TCSR register.
*
* @param base SAI base pointer.
* @param isEnabled Is FIFO error continue enabled, true means enable, false means disable.
*/
static inline void SAI_TxSetFIFOErrorContinue(I2S_Type *base, bool isEnabled)
{
if (isEnabled)
{
base->TCR4 |= I2S_TCR4_FCONT_MASK;
}
else
{
base->TCR4 &= ~I2S_TCR4_FCONT_MASK;
}
}
/*!
* @brief Set Rx FIFO error continue.
*
* FIFO error continue mode means SAI will keep running while FIFO error occured. If this feature
* not enabled, SAI will hang and users need to clear FEF flag in RCSR register.
*
* @param base SAI base pointer.
* @param isEnabled Is FIFO error continue enabled, true means enable, false means disable.
*/
static inline void SAI_RxSetFIFOErrorContinue(I2S_Type *base, bool isEnabled)
{
if (isEnabled)
{
base->RCR4 |= I2S_RCR4_FCONT_MASK;
}
else
{
base->RCR4 &= ~I2S_RCR4_FCONT_MASK;
}
}
#endif
/*! @} */
/*!
@ -633,6 +830,21 @@ void SAI_RxSetFormat(I2S_Type *base,
*/
void SAI_WriteBlocking(I2S_Type *base, uint32_t channel, uint32_t bitWidth, uint8_t *buffer, uint32_t size);
/*!
* @brief Sends data to multi channel using a blocking method.
*
* @note This function blocks by polling until data is ready to be sent.
*
* @param base SAI base pointer.
* @param channel Data channel used.
* @param channelMask channel mask.
* @param bitWidth How many bits in an audio word; usually 8/16/24/32 bits.
* @param buffer Pointer to the data to be written.
* @param size Bytes to be written.
*/
void SAI_WriteMultiChannelBlocking(
I2S_Type *base, uint32_t channel, uint32_t channelMask, uint32_t bitWidth, uint8_t *buffer, uint32_t size);
/*!
* @brief Writes data into SAI FIFO.
*
@ -658,6 +870,21 @@ static inline void SAI_WriteData(I2S_Type *base, uint32_t channel, uint32_t data
*/
void SAI_ReadBlocking(I2S_Type *base, uint32_t channel, uint32_t bitWidth, uint8_t *buffer, uint32_t size);
/*!
* @brief Receives multi channel data using a blocking method.
*
* @note This function blocks by polling until data is ready to be sent.
*
* @param base SAI base pointer.
* @param channel Data channel used.
* @param channelMask channel mask.
* @param bitWidth How many bits in an audio word; usually 8/16/24/32 bits.
* @param buffer Pointer to the data to be read.
* @param size Bytes to be read.
*/
void SAI_ReadMultiChannelBlocking(
I2S_Type *base, uint32_t channel, uint32_t channelMask, uint32_t bitWidth, uint8_t *buffer, uint32_t size);
/*!
* @brief Reads data from the SAI FIFO.
*
@ -811,7 +1038,7 @@ status_t SAI_TransferGetReceiveCount(I2S_Type *base, sai_handle_t *handle, size_
void SAI_TransferAbortSend(I2S_Type *base, sai_handle_t *handle);
/*!
* @brief Aborts the the current IRQ receive.
* @brief Aborts the current IRQ receive.
*
* @note This API can be called when an interrupt non-blocking transfer initiates
* to abort the transfer early.
@ -821,6 +1048,28 @@ void SAI_TransferAbortSend(I2S_Type *base, sai_handle_t *handle);
*/
void SAI_TransferAbortReceive(I2S_Type *base, sai_handle_t *handle);
/*!
* @brief Terminate all SAI send.
*
* This function will clear all transfer slots buffered in the sai queue. If users only want to abort the
* current transfer slot, please call SAI_TransferAbortSend.
*
* @param base SAI base pointer.
* @param handle SAI eDMA handle pointer.
*/
void SAI_TransferTerminateSend(I2S_Type *base, sai_handle_t *handle);
/*!
* @brief Terminate all SAI receive.
*
* This function will clear all transfer slots buffered in the sai queue. If users only want to abort the
* current transfer slot, please call SAI_TransferAbortReceive.
*
* @param base SAI base pointer.
* @param handle SAI eDMA handle pointer.
*/
void SAI_TransferTerminateReceive(I2S_Type *base, sai_handle_t *handle);
/*!
* @brief Tx interrupt handler.
*

266
targets/TARGET_Freescale/TARGET_MCUXpresso_MCUS/TARGET_K66F/drivers/fsl_sai_edma.c
View File

@ -1,40 +1,25 @@
/*
* Copyright (c) 2015, Freescale Semiconductor, Inc.
* Copyright 2016-2017 NXP
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* o Redistributions of source code must retain the above copyright notice, this list
* of conditions and the following disclaimer.
*
* o Redistributions in binary form must reproduce the above copyright notice, this
* list of conditions and the following disclaimer in the documentation and/or
* other materials provided with the distribution.
*
* o Neither the name of the copyright holder nor the names of its
* contributors may be used to endorse or promote products derived from this
* software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
* ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* SPDX-License-Identifier: BSD-3-Clause
*/
#include "fsl_sai_edma.h"
/* Component ID definition, used by tools. */
#ifndef FSL_COMPONENT_ID
#define FSL_COMPONENT_ID "platform.drivers.sai_edma"
#endif
/*******************************************************************************
* Definitations
******************************************************************************/
/* Used for 32byte aligned */
#define STCD_ADDR(address) (edma_tcd_t *)(((uint32_t)address + 32) & ~0x1FU)
#define STCD_ADDR(address) (edma_tcd_t *)(((uint32_t)(address) + 32) & ~0x1FU)
static I2S_Type *const s_saiBases[] = I2S_BASE_PTRS;
/*<! Structure definition for uart_edma_private_handle_t. The structure is private. */
typedef struct _sai_edma_private_handle
@ -50,7 +35,7 @@ enum _sai_edma_transfer_state
};
/*<! Private handle only used for internally. */
static sai_edma_private_handle_t s_edmaPrivateHandle[FSL_FEATURE_SOC_I2S_COUNT][2];
static sai_edma_private_handle_t s_edmaPrivateHandle[ARRAY_SIZE(s_saiBases)][2];
/*******************************************************************************
* Prototypes
@ -60,7 +45,7 @@ static sai_edma_private_handle_t s_edmaPrivateHandle[FSL_FEATURE_SOC_I2S_COUNT][
*
* @param base SAI base pointer.
*/
extern uint32_t SAI_GetInstance(I2S_Type *base);
static uint32_t SAI_GetInstance(I2S_Type *base);
/*!
* @brief SAI EDMA callback for send.
@ -85,6 +70,24 @@ static void SAI_RxEDMACallback(edma_handle_t *handle, void *userData, bool done,
/*******************************************************************************
* Code
******************************************************************************/
static uint32_t SAI_GetInstance(I2S_Type *base)
{
uint32_t instance;
/* Find the instance index from base address mappings. */
for (instance = 0; instance < ARRAY_SIZE(s_saiBases); instance++)
{
if (s_saiBases[instance] == base)
{
break;
}
}
assert(instance < ARRAY_SIZE(s_saiBases));
return instance;
}
static void SAI_TxEDMACallback(edma_handle_t *handle, void *userData, bool done, uint32_t tcds)
{
sai_edma_private_handle_t *privHandle = (sai_edma_private_handle_t *)userData;
@ -101,7 +104,9 @@ static void SAI_TxEDMACallback(edma_handle_t *handle, void *userData, bool done,
/* If all data finished, just stop the transfer */
if (saiHandle->saiQueue[saiHandle->queueDriver].data == NULL)
{
SAI_TransferAbortSendEDMA(privHandle->base, saiHandle);
/* Disable DMA enable bit */
SAI_TxEnableDMA(privHandle->base, kSAI_FIFORequestDMAEnable, false);
EDMA_AbortTransfer(handle);
}
}
@ -121,10 +126,25 @@ static void SAI_RxEDMACallback(edma_handle_t *handle, void *userData, bool done,
/* If all data finished, just stop the transfer */
if (saiHandle->saiQueue[saiHandle->queueDriver].data == NULL)
{
SAI_TransferAbortReceiveEDMA(privHandle->base, saiHandle);
/* Disable DMA enable bit */
SAI_RxEnableDMA(privHandle->base, kSAI_FIFORequestDMAEnable, false);
EDMA_AbortTransfer(handle);
}
}
/*!
* brief Initializes the SAI eDMA handle.
*
* This function initializes the SAI master DMA handle, which can be used for other SAI master transactional APIs.
* Usually, for a specified SAI instance, call this API once to get the initialized handle.
*
* param base SAI base pointer.
* param handle SAI eDMA handle pointer.
* param base SAI peripheral base address.
* param callback Pointer to user callback function.
* param userData User parameter passed to the callback function.
* param dmaHandle eDMA handle pointer, this handle shall be static allocated by users.
*/
void SAI_TransferTxCreateHandleEDMA(
I2S_Type *base, sai_edma_handle_t *handle, sai_edma_callback_t callback, void *userData, edma_handle_t *dmaHandle)
{
@ -147,12 +167,25 @@ void SAI_TransferTxCreateHandleEDMA(
s_edmaPrivateHandle[instance][0].handle = handle;
/* Need to use scatter gather */
EDMA_InstallTCDMemory(dmaHandle, STCD_ADDR(handle->tcd), SAI_XFER_QUEUE_SIZE);
EDMA_InstallTCDMemory(dmaHandle, (edma_tcd_t *)(STCD_ADDR(handle->tcd)), SAI_XFER_QUEUE_SIZE);
/* Install callback for Tx dma channel */
EDMA_SetCallback(dmaHandle, SAI_TxEDMACallback, &s_edmaPrivateHandle[instance][0]);
}
/*!
* brief Initializes the SAI Rx eDMA handle.
*
* This function initializes the SAI slave DMA handle, which can be used for other SAI master transactional APIs.
* Usually, for a specified SAI instance, call this API once to get the initialized handle.
*
* param base SAI base pointer.
* param handle SAI eDMA handle pointer.
* param base SAI peripheral base address.
* param callback Pointer to user callback function.
* param userData User parameter passed to the callback function.
* param dmaHandle eDMA handle pointer, this handle shall be static allocated by users.
*/
void SAI_TransferRxCreateHandleEDMA(
I2S_Type *base, sai_edma_handle_t *handle, sai_edma_callback_t callback, void *userData, edma_handle_t *dmaHandle)
{
@ -181,6 +214,21 @@ void SAI_TransferRxCreateHandleEDMA(
EDMA_SetCallback(dmaHandle, SAI_RxEDMACallback, &s_edmaPrivateHandle[instance][1]);
}
/*!
* brief Configures the SAI Tx audio format.
*
* The audio format can be changed at run-time. This function configures the sample rate and audio data
* format to be transferred. This function also sets the eDMA parameter according to formatting requirements.
*
* param base SAI base pointer.
* param handle SAI eDMA handle pointer.
* param format Pointer to SAI audio data format structure.
* param mclkSourceClockHz SAI master clock source frequency in Hz.
* param bclkSourceClockHz SAI bit clock source frequency in Hz. If bit clock source is master
* clock, this value should equals to masterClockHz in format.
* retval kStatus_Success Audio format set successfully.
* retval kStatus_InvalidArgument The input argument is invalid.
*/
void SAI_TransferTxSetFormatEDMA(I2S_Type *base,
sai_edma_handle_t *handle,
sai_transfer_format_t *format,
@ -204,6 +252,9 @@ void SAI_TransferTxSetFormatEDMA(I2S_Type *base,
/* Update the data channel SAI used */
handle->channel = format->channel;
/* Clear the channel enable bits unitl do a send/receive */
base->TCR3 &= ~I2S_TCR3_TCE_MASK;
#if defined(FSL_FEATURE_SAI_FIFO_COUNT) && (FSL_FEATURE_SAI_FIFO_COUNT > 1)
handle->count = FSL_FEATURE_SAI_FIFO_COUNT - format->watermark;
#else
@ -211,6 +262,21 @@ void SAI_TransferTxSetFormatEDMA(I2S_Type *base,
#endif /* FSL_FEATURE_SAI_FIFO_COUNT */
}
/*!
* brief Configures the SAI Rx audio format.
*
* The audio format can be changed at run-time. This function configures the sample rate and audio data
* format to be transferred. This function also sets the eDMA parameter according to formatting requirements.
*
* param base SAI base pointer.
* param handle SAI eDMA handle pointer.
* param format Pointer to SAI audio data format structure.
* param mclkSourceClockHz SAI master clock source frequency in Hz.
* param bclkSourceClockHz SAI bit clock source frequency in Hz. If a bit clock source is the master
* clock, this value should equal to masterClockHz in format.
* retval kStatus_Success Audio format set successfully.
* retval kStatus_InvalidArgument The input argument is invalid.
*/
void SAI_TransferRxSetFormatEDMA(I2S_Type *base,
sai_edma_handle_t *handle,
sai_transfer_format_t *format,
@ -235,6 +301,8 @@ void SAI_TransferRxSetFormatEDMA(I2S_Type *base,
/* Update the data channel SAI used */
handle->channel = format->channel;
/* Clear the channel enable bits unitl do a send/receive */
base->RCR3 &= ~I2S_RCR3_RCE_MASK;
#if defined(FSL_FEATURE_SAI_FIFO_COUNT) && (FSL_FEATURE_SAI_FIFO_COUNT > 1)
handle->count = format->watermark;
#else
@ -242,6 +310,19 @@ void SAI_TransferRxSetFormatEDMA(I2S_Type *base,
#endif /* FSL_FEATURE_SAI_FIFO_COUNT */
}
/*!
* brief Performs a non-blocking SAI transfer using DMA.
*
* note This interface returns immediately after the transfer initiates. Call
* SAI_GetTransferStatus to poll the transfer status and check whether the SAI transfer is finished.
*
* param base SAI base pointer.
* param handle SAI eDMA handle pointer.
* param xfer Pointer to the DMA transfer structure.
* retval kStatus_Success Start a SAI eDMA send successfully.
* retval kStatus_InvalidArgument The input argument is invalid.
* retval kStatus_TxBusy SAI is busy sending data.
*/
status_t SAI_TransferSendEDMA(I2S_Type *base, sai_edma_handle_t *handle, sai_transfer_t *xfer)
{
assert(handle && xfer);
@ -287,9 +368,25 @@ status_t SAI_TransferSendEDMA(I2S_Type *base, sai_edma_handle_t *handle, sai_tra
/* Enable SAI Tx clock */
SAI_TxEnable(base, true);
/* Enable the channel FIFO */
base->TCR3 |= I2S_TCR3_TCE(1U << handle->channel);
return kStatus_Success;
}
/*!
* brief Performs a non-blocking SAI receive using eDMA.
*
* note This interface returns immediately after the transfer initiates. Call
* the SAI_GetReceiveRemainingBytes to poll the transfer status and check whether the SAI transfer is finished.
*
* param base SAI base pointer
* param handle SAI eDMA handle pointer.
* param xfer Pointer to DMA transfer structure.
* retval kStatus_Success Start a SAI eDMA receive successfully.
* retval kStatus_InvalidArgument The input argument is invalid.
* retval kStatus_RxBusy SAI is busy receiving data.
*/
status_t SAI_TransferReceiveEDMA(I2S_Type *base, sai_edma_handle_t *handle, sai_transfer_t *xfer)
{
assert(handle && xfer);
@ -332,12 +429,24 @@ status_t SAI_TransferReceiveEDMA(I2S_Type *base, sai_edma_handle_t *handle, sai_
/* Enable DMA enable bit */
SAI_RxEnableDMA(base, kSAI_FIFORequestDMAEnable, true);
/* Enable the channel FIFO */
base->RCR3 |= I2S_RCR3_RCE(1U << handle->channel);
/* Enable SAI Rx clock */
SAI_RxEnable(base, true);
return kStatus_Success;
}
/*!
* brief Aborts a SAI transfer using eDMA.
*
* This function only aborts the current transfer slots, the other transfer slots' information still kept
* in the handler. If users want to terminate all transfer slots, just call SAI_TransferTerminateSendEDMA.
*
* param base SAI base pointer.
* param handle SAI eDMA handle pointer.
*/
void SAI_TransferAbortSendEDMA(I2S_Type *base, sai_edma_handle_t *handle)
{
assert(handle);
@ -345,16 +454,36 @@ void SAI_TransferAbortSendEDMA(I2S_Type *base, sai_edma_handle_t *handle)
/* Disable dma */
EDMA_AbortTransfer(handle->dmaHandle);
/* Disable the channel FIFO */
base->TCR3 &= ~I2S_TCR3_TCE_MASK;
/* Disable DMA enable bit */
SAI_TxEnableDMA(base, kSAI_FIFORequestDMAEnable, false);
/* Disable Tx */
SAI_TxEnable(base, false);
/* Reset the FIFO pointer, at the same time clear all error flags if set */
base->TCSR |= (I2S_TCSR_FR_MASK | I2S_TCSR_SR_MASK);
base->TCSR &= ~I2S_TCSR_SR_MASK;
/* Handle the queue index */
memset(&handle->saiQueue[handle->queueDriver], 0, sizeof(sai_transfer_t));
handle->queueDriver = (handle->queueDriver + 1) % SAI_XFER_QUEUE_SIZE;
/* Set the handle state */
handle->state = kSAI_Idle;
}
/*!
* brief Aborts a SAI receive using eDMA.
*
* This function only aborts the current transfer slots, the other transfer slots' information still kept
* in the handler. If users want to terminate all transfer slots, just call SAI_TransferTerminateReceiveEDMA.
*
* param base SAI base pointer
* param handle SAI eDMA handle pointer.
*/
void SAI_TransferAbortReceiveEDMA(I2S_Type *base, sai_edma_handle_t *handle)
{
assert(handle);
@ -362,16 +491,84 @@ void SAI_TransferAbortReceiveEDMA(I2S_Type *base, sai_edma_handle_t *handle)
/* Disable dma */
EDMA_AbortTransfer(handle->dmaHandle);
/* Disable the channel FIFO */
base->RCR3 &= ~I2S_RCR3_RCE_MASK;
/* Disable DMA enable bit */
SAI_RxEnableDMA(base, kSAI_FIFORequestDMAEnable, false);
/* Disable Rx */
SAI_RxEnable(base, false);
/* Reset the FIFO pointer, at the same time clear all error flags if set */
base->RCSR |= (I2S_RCSR_FR_MASK | I2S_RCSR_SR_MASK);
base->RCSR &= ~I2S_RCSR_SR_MASK;
/* Handle the queue index */
memset(&handle->saiQueue[handle->queueDriver], 0, sizeof(sai_transfer_t));
handle->queueDriver = (handle->queueDriver + 1) % SAI_XFER_QUEUE_SIZE;
/* Set the handle state */
handle->state = kSAI_Idle;
}
/*!
* brief Terminate all SAI send.
*
* This function will clear all transfer slots buffered in the sai queue. If users only want to abort the
* current transfer slot, please call SAI_TransferAbortSendEDMA.
*
* param base SAI base pointer.
* param handle SAI eDMA handle pointer.
*/
void SAI_TransferTerminateSendEDMA(I2S_Type *base, sai_edma_handle_t *handle)
{
assert(handle);
/* Abort the current transfer */
SAI_TransferAbortSendEDMA(base, handle);
/* Clear all the internal information */
memset(handle->tcd, 0U, sizeof(handle->tcd));
memset(handle->saiQueue, 0U, sizeof(handle->saiQueue));
memset(handle->transferSize, 0U, sizeof(handle->transferSize));
handle->queueUser = 0U;
handle->queueDriver = 0U;
}
/*!
* brief Terminate all SAI receive.
*
* This function will clear all transfer slots buffered in the sai queue. If users only want to abort the
* current transfer slot, please call SAI_TransferAbortReceiveEDMA.
*
* param base SAI base pointer.
* param handle SAI eDMA handle pointer.
*/
void SAI_TransferTerminateReceiveEDMA(I2S_Type *base, sai_edma_handle_t *handle)
{
assert(handle);
/* Abort the current transfer */
SAI_TransferAbortReceiveEDMA(base, handle);
/* Clear all the internal information */
memset(handle->tcd, 0U, sizeof(handle->tcd));
memset(handle->saiQueue, 0U, sizeof(handle->saiQueue));
memset(handle->transferSize, 0U, sizeof(handle->transferSize));
handle->queueUser = 0U;
handle->queueDriver = 0U;
}
/*!
* brief Gets byte count sent by SAI.
*
* param base SAI base pointer.
* param handle SAI eDMA handle pointer.
* param count Bytes count sent by SAI.
* retval kStatus_Success Succeed get the transfer count.
* retval kStatus_NoTransferInProgress There is no non-blocking transaction in progress.
*/
status_t SAI_TransferGetSendCountEDMA(I2S_Type *base, sai_edma_handle_t *handle, size_t *count)
{
assert(handle);
@ -392,6 +589,15 @@ status_t SAI_TransferGetSendCountEDMA(I2S_Type *base, sai_edma_handle_t *handle,
return status;
}
/*!
* brief Gets byte count received by SAI.
*
* param base SAI base pointer
* param handle SAI eDMA handle pointer.
* param count Bytes count received by SAI.
* retval kStatus_Success Succeed get the transfer count.
* retval kStatus_NoTransferInProgress There is no non-blocking transaction in progress.
*/
status_t SAI_TransferGetReceiveCountEDMA(I2S_Type *base, sai_edma_handle_t *handle, size_t *count)
{
assert(handle);

85
targets/TARGET_Freescale/TARGET_MCUXpresso_MCUS/TARGET_K66F/drivers/fsl_sai_edma.h
View File

@ -1,31 +1,9 @@
/*
* Copyright (c) 2015, Freescale Semiconductor, Inc.
* Copyright 2016-2017 NXP
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* o Redistributions of source code must retain the above copyright notice, this list
* of conditions and the following disclaimer.
*
* o Redistributions in binary form must reproduce the above copyright notice, this
* list of conditions and the following disclaimer in the documentation and/or
* other materials provided with the distribution.
*
* o Neither the name of the copyright holder nor the names of its
* contributors may be used to endorse or promote products derived from this
* software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
* ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* SPDX-License-Identifier: BSD-3-Clause
*/
#ifndef _FSL_SAI_EDMA_H_
#define _FSL_SAI_EDMA_H_
@ -42,6 +20,11 @@
* Definitions
******************************************************************************/
/*! @name Driver version */
/*@{*/
#define FSL_SAI_EDMA_DRIVER_VERSION (MAKE_VERSION(2, 1, 5)) /*!< Version 2.1.5 */
/*@}*/
typedef struct _sai_edma_handle sai_edma_handle_t;
/*! @brief SAI eDMA transfer callback function for finish and error */
@ -50,19 +33,19 @@ typedef void (*sai_edma_callback_t)(I2S_Type *base, sai_edma_handle_t *handle, s
/*! @brief SAI DMA transfer handle, users should not touch the content of the handle.*/
struct _sai_edma_handle
{
edma_handle_t *dmaHandle; /*!< DMA handler for SAI send */
uint8_t nbytes; /*!< eDMA minor byte transfer count initially configured. */
uint8_t bytesPerFrame; /*!< Bytes in a frame */
uint8_t channel; /*!< Which data channel */
uint8_t count; /*!< The transfer data count in a DMA request */
uint32_t state; /*!< Internal state for SAI eDMA transfer */
sai_edma_callback_t callback; /*!< Callback for users while transfer finish or error occurs */
void *userData; /*!< User callback parameter */
edma_tcd_t tcd[SAI_XFER_QUEUE_SIZE + 1U]; /*!< TCD pool for eDMA transfer. */
sai_transfer_t saiQueue[SAI_XFER_QUEUE_SIZE]; /*!< Transfer queue storing queued transfer. */
size_t transferSize[SAI_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 */
edma_handle_t *dmaHandle; /*!< DMA handler for SAI send */
uint8_t nbytes; /*!< eDMA minor byte transfer count initially configured. */
uint8_t bytesPerFrame; /*!< Bytes in a frame */
uint8_t channel; /*!< Which data channel */
uint8_t count; /*!< The transfer data count in a DMA request */
uint32_t state; /*!< Internal state for SAI eDMA transfer */
sai_edma_callback_t callback; /*!< Callback for users while transfer finish or error occurs */
void *userData; /*!< User callback parameter */
uint8_t tcd[(SAI_XFER_QUEUE_SIZE + 1U) * sizeof(edma_tcd_t)]; /*!< TCD pool for eDMA transfer. */
sai_transfer_t saiQueue[SAI_XFER_QUEUE_SIZE]; /*!< Transfer queue storing queued transfer. */
size_t transferSize[SAI_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 */
};
/*******************************************************************************
@ -181,9 +164,34 @@ status_t SAI_TransferSendEDMA(I2S_Type *base, sai_edma_handle_t *handle, sai_tra
*/
status_t SAI_TransferReceiveEDMA(I2S_Type *base, sai_edma_handle_t *handle, sai_transfer_t *xfer);
/*!
* @brief Terminate all SAI send.
*
* This function will clear all transfer slots buffered in the sai queue. If users only want to abort the
* current transfer slot, please call SAI_TransferAbortSendEDMA.
*
* @param base SAI base pointer.
* @param handle SAI eDMA handle pointer.
*/
void SAI_TransferTerminateSendEDMA(I2S_Type *base, sai_edma_handle_t *handle);
/*!
* @brief Terminate all SAI receive.
*
* This function will clear all transfer slots buffered in the sai queue. If users only want to abort the
* current transfer slot, please call SAI_TransferAbortReceiveEDMA.
*
* @param base SAI base pointer.
* @param handle SAI eDMA handle pointer.
*/
void SAI_TransferTerminateReceiveEDMA(I2S_Type *base, sai_edma_handle_t *handle);
/*!
* @brief Aborts a SAI transfer using eDMA.
*
* This function only aborts the current transfer slots, the other transfer slots' information still kept
* in the handler. If users want to terminate all transfer slots, just call SAI_TransferTerminateSendEDMA.
*
* @param base SAI base pointer.
* @param handle SAI eDMA handle pointer.
*/
@ -192,6 +200,9 @@ void SAI_TransferAbortSendEDMA(I2S_Type *base, sai_edma_handle_t *handle);
/*!
* @brief Aborts a SAI receive using eDMA.
*
* This function only aborts the current transfer slots, the other transfer slots' information still kept
* in the handler. If users want to terminate all transfer slots, just call SAI_TransferTerminateReceiveEDMA.
*
* @param base SAI base pointer
* @param handle SAI eDMA handle pointer.
*/