Johannes Stratmann / mbed-dev

added prescaler for 16 bit pwm in LPC1347 target

Fork of mbed-dev by mbed official

targets/hal/TARGET_Freescale/TARGET_KSDK2_MCUS/TARGET_K66F/drivers/fsl_sai_edma.c@144:ef7eb2e8f9f7, 2016-09-02 (annotated)

Committer:
<>
Date:
Fri Sep 02 15:07:44 2016 +0100
Revision:
144:ef7eb2e8f9f7
This updates the lib to the mbed lib v125

Who changed what in which revision?

UserRevisionLine numberNew contents of line
<> 144:ef7eb2e8f9f7 1 /*
<> 144:ef7eb2e8f9f7 2 * Copyright (c) 2015, Freescale Semiconductor, Inc.
<> 144:ef7eb2e8f9f7 3 * All rights reserved.
<> 144:ef7eb2e8f9f7 4 *
<> 144:ef7eb2e8f9f7 5 * Redistribution and use in source and binary forms, with or without modification,
<> 144:ef7eb2e8f9f7 6 * are permitted provided that the following conditions are met:
<> 144:ef7eb2e8f9f7 7 *
<> 144:ef7eb2e8f9f7 8 * o Redistributions of source code must retain the above copyright notice, this list
<> 144:ef7eb2e8f9f7 9 * of conditions and the following disclaimer.
<> 144:ef7eb2e8f9f7 10 *
<> 144:ef7eb2e8f9f7 11 * o Redistributions in binary form must reproduce the above copyright notice, this
<> 144:ef7eb2e8f9f7 12 * list of conditions and the following disclaimer in the documentation and/or
<> 144:ef7eb2e8f9f7 13 * other materials provided with the distribution.
<> 144:ef7eb2e8f9f7 14 *
<> 144:ef7eb2e8f9f7 15 * o Neither the name of Freescale Semiconductor, Inc. nor the names of its
<> 144:ef7eb2e8f9f7 16 * contributors may be used to endorse or promote products derived from this
<> 144:ef7eb2e8f9f7 17 * software without specific prior written permission.
<> 144:ef7eb2e8f9f7 18 *
<> 144:ef7eb2e8f9f7 19 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
<> 144:ef7eb2e8f9f7 20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
<> 144:ef7eb2e8f9f7 21 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
<> 144:ef7eb2e8f9f7 22 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
<> 144:ef7eb2e8f9f7 23 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
<> 144:ef7eb2e8f9f7 24 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
<> 144:ef7eb2e8f9f7 25 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
<> 144:ef7eb2e8f9f7 26 * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
<> 144:ef7eb2e8f9f7 27 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
<> 144:ef7eb2e8f9f7 28 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
<> 144:ef7eb2e8f9f7 29 */
<> 144:ef7eb2e8f9f7 30
<> 144:ef7eb2e8f9f7 31 #include "fsl_sai_edma.h"
<> 144:ef7eb2e8f9f7 32
<> 144:ef7eb2e8f9f7 33 /*******************************************************************************
<> 144:ef7eb2e8f9f7 34 * Definitations
<> 144:ef7eb2e8f9f7 35 ******************************************************************************/
<> 144:ef7eb2e8f9f7 36 /* Used for 32byte aligned */
<> 144:ef7eb2e8f9f7 37 #define STCD_ADDR(address) (edma_tcd_t *)(((uint32_t)address + 32) & ~0x1FU)
<> 144:ef7eb2e8f9f7 38
<> 144:ef7eb2e8f9f7 39 /*<! Structure definition for uart_edma_private_handle_t. The structure is private. */
<> 144:ef7eb2e8f9f7 40 typedef struct _sai_edma_private_handle
<> 144:ef7eb2e8f9f7 41 {
<> 144:ef7eb2e8f9f7 42 I2S_Type *base;
<> 144:ef7eb2e8f9f7 43 sai_edma_handle_t *handle;
<> 144:ef7eb2e8f9f7 44 } sai_edma_private_handle_t;
<> 144:ef7eb2e8f9f7 45
<> 144:ef7eb2e8f9f7 46 enum _sai_edma_transfer_state
<> 144:ef7eb2e8f9f7 47 {
<> 144:ef7eb2e8f9f7 48 kSAI_Busy = 0x0U, /*!< SAI is busy */
<> 144:ef7eb2e8f9f7 49 kSAI_Idle, /*!< Transfer is done. */
<> 144:ef7eb2e8f9f7 50 };
<> 144:ef7eb2e8f9f7 51
<> 144:ef7eb2e8f9f7 52 /*<! Private handle only used for internally. */
<> 144:ef7eb2e8f9f7 53 static sai_edma_private_handle_t s_edmaPrivateHandle[FSL_FEATURE_SOC_I2S_COUNT][2];
<> 144:ef7eb2e8f9f7 54
<> 144:ef7eb2e8f9f7 55 /*******************************************************************************
<> 144:ef7eb2e8f9f7 56 * Prototypes
<> 144:ef7eb2e8f9f7 57 ******************************************************************************/
<> 144:ef7eb2e8f9f7 58 /*!
<> 144:ef7eb2e8f9f7 59 * @brief Get the instance number for SAI.
<> 144:ef7eb2e8f9f7 60 *
<> 144:ef7eb2e8f9f7 61 * @param base SAI base pointer.
<> 144:ef7eb2e8f9f7 62 */
<> 144:ef7eb2e8f9f7 63 extern uint32_t SAI_GetInstance(I2S_Type *base);
<> 144:ef7eb2e8f9f7 64
<> 144:ef7eb2e8f9f7 65 /*!
<> 144:ef7eb2e8f9f7 66 * @brief SAI EDMA callback for send.
<> 144:ef7eb2e8f9f7 67 *
<> 144:ef7eb2e8f9f7 68 * @param handle pointer to sai_edma_handle_t structure which stores the transfer state.
<> 144:ef7eb2e8f9f7 69 * @param userData Parameter for user callback.
<> 144:ef7eb2e8f9f7 70 * @param done If the DMA transfer finished.
<> 144:ef7eb2e8f9f7 71 * @param tcds The TCD index.
<> 144:ef7eb2e8f9f7 72 */
<> 144:ef7eb2e8f9f7 73 static void SAI_TxEDMACallback(edma_handle_t *handle, void *userData, bool done, uint32_t tcds);
<> 144:ef7eb2e8f9f7 74
<> 144:ef7eb2e8f9f7 75 /*!
<> 144:ef7eb2e8f9f7 76 * @brief SAI EDMA callback for receive.
<> 144:ef7eb2e8f9f7 77 *
<> 144:ef7eb2e8f9f7 78 * @param handle pointer to sai_edma_handle_t structure which stores the transfer state.
<> 144:ef7eb2e8f9f7 79 * @param userData Parameter for user callback.
<> 144:ef7eb2e8f9f7 80 * @param done If the DMA transfer finished.
<> 144:ef7eb2e8f9f7 81 * @param tcds The TCD index.
<> 144:ef7eb2e8f9f7 82 */
<> 144:ef7eb2e8f9f7 83 static void SAI_RxEDMACallback(edma_handle_t *handle, void *userData, bool done, uint32_t tcds);
<> 144:ef7eb2e8f9f7 84
<> 144:ef7eb2e8f9f7 85 /*******************************************************************************
<> 144:ef7eb2e8f9f7 86 * Code
<> 144:ef7eb2e8f9f7 87 ******************************************************************************/
<> 144:ef7eb2e8f9f7 88 static void SAI_TxEDMACallback(edma_handle_t *handle, void *userData, bool done, uint32_t tcds)
<> 144:ef7eb2e8f9f7 89 {
<> 144:ef7eb2e8f9f7 90 sai_edma_private_handle_t *privHandle = (sai_edma_private_handle_t *)userData;
<> 144:ef7eb2e8f9f7 91 sai_edma_handle_t *saiHandle = privHandle->handle;
<> 144:ef7eb2e8f9f7 92
<> 144:ef7eb2e8f9f7 93 /* If finished a blcok, call the callback function */
<> 144:ef7eb2e8f9f7 94 memset(&saiHandle->saiQueue[saiHandle->queueDriver], 0, sizeof(sai_transfer_t));
<> 144:ef7eb2e8f9f7 95 saiHandle->queueDriver = (saiHandle->queueDriver + 1) % SAI_XFER_QUEUE_SIZE;
<> 144:ef7eb2e8f9f7 96 if (saiHandle->callback)
<> 144:ef7eb2e8f9f7 97 {
<> 144:ef7eb2e8f9f7 98 (saiHandle->callback)(privHandle->base, saiHandle, kStatus_SAI_TxIdle, saiHandle->userData);
<> 144:ef7eb2e8f9f7 99 }
<> 144:ef7eb2e8f9f7 100
<> 144:ef7eb2e8f9f7 101 /* If all data finished, just stop the transfer */
<> 144:ef7eb2e8f9f7 102 if (saiHandle->saiQueue[saiHandle->queueDriver].data == NULL)
<> 144:ef7eb2e8f9f7 103 {
<> 144:ef7eb2e8f9f7 104 SAI_TransferAbortSendEDMA(privHandle->base, saiHandle);
<> 144:ef7eb2e8f9f7 105 }
<> 144:ef7eb2e8f9f7 106 }
<> 144:ef7eb2e8f9f7 107
<> 144:ef7eb2e8f9f7 108 static void SAI_RxEDMACallback(edma_handle_t *handle, void *userData, bool done, uint32_t tcds)
<> 144:ef7eb2e8f9f7 109 {
<> 144:ef7eb2e8f9f7 110 sai_edma_private_handle_t *privHandle = (sai_edma_private_handle_t *)userData;
<> 144:ef7eb2e8f9f7 111 sai_edma_handle_t *saiHandle = privHandle->handle;
<> 144:ef7eb2e8f9f7 112
<> 144:ef7eb2e8f9f7 113 /* If finished a blcok, call the callback function */
<> 144:ef7eb2e8f9f7 114 memset(&saiHandle->saiQueue[saiHandle->queueDriver], 0, sizeof(sai_transfer_t));
<> 144:ef7eb2e8f9f7 115 saiHandle->queueDriver = (saiHandle->queueDriver + 1) % SAI_XFER_QUEUE_SIZE;
<> 144:ef7eb2e8f9f7 116 if (saiHandle->callback)
<> 144:ef7eb2e8f9f7 117 {
<> 144:ef7eb2e8f9f7 118 (saiHandle->callback)(privHandle->base, saiHandle, kStatus_SAI_RxIdle, saiHandle->userData);
<> 144:ef7eb2e8f9f7 119 }
<> 144:ef7eb2e8f9f7 120
<> 144:ef7eb2e8f9f7 121 /* If all data finished, just stop the transfer */
<> 144:ef7eb2e8f9f7 122 if (saiHandle->saiQueue[saiHandle->queueDriver].data == NULL)
<> 144:ef7eb2e8f9f7 123 {
<> 144:ef7eb2e8f9f7 124 SAI_TransferAbortReceiveEDMA(privHandle->base, saiHandle);
<> 144:ef7eb2e8f9f7 125 }
<> 144:ef7eb2e8f9f7 126 }
<> 144:ef7eb2e8f9f7 127
<> 144:ef7eb2e8f9f7 128 void SAI_TransferTxCreateHandleEDMA(
<> 144:ef7eb2e8f9f7 129 I2S_Type *base, sai_edma_handle_t *handle, sai_edma_callback_t callback, void *userData, edma_handle_t *dmaHandle)
<> 144:ef7eb2e8f9f7 130 {
<> 144:ef7eb2e8f9f7 131 assert(handle && dmaHandle);
<> 144:ef7eb2e8f9f7 132
<> 144:ef7eb2e8f9f7 133 uint32_t instance = SAI_GetInstance(base);
<> 144:ef7eb2e8f9f7 134
<> 144:ef7eb2e8f9f7 135 /* Set sai base to handle */
<> 144:ef7eb2e8f9f7 136 handle->dmaHandle = dmaHandle;
<> 144:ef7eb2e8f9f7 137 handle->callback = callback;
<> 144:ef7eb2e8f9f7 138 handle->userData = userData;
<> 144:ef7eb2e8f9f7 139
<> 144:ef7eb2e8f9f7 140 /* Set SAI state to idle */
<> 144:ef7eb2e8f9f7 141 handle->state = kSAI_Idle;
<> 144:ef7eb2e8f9f7 142
<> 144:ef7eb2e8f9f7 143 s_edmaPrivateHandle[instance][0].base = base;
<> 144:ef7eb2e8f9f7 144 s_edmaPrivateHandle[instance][0].handle = handle;
<> 144:ef7eb2e8f9f7 145
<> 144:ef7eb2e8f9f7 146 /* Need to use scatter gather */
<> 144:ef7eb2e8f9f7 147 EDMA_InstallTCDMemory(dmaHandle, STCD_ADDR(handle->tcd), SAI_XFER_QUEUE_SIZE);
<> 144:ef7eb2e8f9f7 148
<> 144:ef7eb2e8f9f7 149 /* Install callback for Tx dma channel */
<> 144:ef7eb2e8f9f7 150 EDMA_SetCallback(dmaHandle, SAI_TxEDMACallback, &s_edmaPrivateHandle[instance][0]);
<> 144:ef7eb2e8f9f7 151 }
<> 144:ef7eb2e8f9f7 152
<> 144:ef7eb2e8f9f7 153 void SAI_TransferRxCreateHandleEDMA(
<> 144:ef7eb2e8f9f7 154 I2S_Type *base, sai_edma_handle_t *handle, sai_edma_callback_t callback, void *userData, edma_handle_t *dmaHandle)
<> 144:ef7eb2e8f9f7 155 {
<> 144:ef7eb2e8f9f7 156 assert(handle && dmaHandle);
<> 144:ef7eb2e8f9f7 157
<> 144:ef7eb2e8f9f7 158 uint32_t instance = SAI_GetInstance(base);
<> 144:ef7eb2e8f9f7 159
<> 144:ef7eb2e8f9f7 160 /* Set sai base to handle */
<> 144:ef7eb2e8f9f7 161 handle->dmaHandle = dmaHandle;
<> 144:ef7eb2e8f9f7 162 handle->callback = callback;
<> 144:ef7eb2e8f9f7 163 handle->userData = userData;
<> 144:ef7eb2e8f9f7 164
<> 144:ef7eb2e8f9f7 165 /* Set SAI state to idle */
<> 144:ef7eb2e8f9f7 166 handle->state = kSAI_Idle;
<> 144:ef7eb2e8f9f7 167
<> 144:ef7eb2e8f9f7 168 s_edmaPrivateHandle[instance][1].base = base;
<> 144:ef7eb2e8f9f7 169 s_edmaPrivateHandle[instance][1].handle = handle;
<> 144:ef7eb2e8f9f7 170
<> 144:ef7eb2e8f9f7 171 /* Need to use scatter gather */
<> 144:ef7eb2e8f9f7 172 EDMA_InstallTCDMemory(dmaHandle, STCD_ADDR(handle->tcd), SAI_XFER_QUEUE_SIZE);
<> 144:ef7eb2e8f9f7 173
<> 144:ef7eb2e8f9f7 174 /* Install callback for Tx dma channel */
<> 144:ef7eb2e8f9f7 175 EDMA_SetCallback(dmaHandle, SAI_RxEDMACallback, &s_edmaPrivateHandle[instance][1]);
<> 144:ef7eb2e8f9f7 176 }
<> 144:ef7eb2e8f9f7 177
<> 144:ef7eb2e8f9f7 178 void SAI_TransferTxSetFormatEDMA(I2S_Type *base,
<> 144:ef7eb2e8f9f7 179 sai_edma_handle_t *handle,
<> 144:ef7eb2e8f9f7 180 sai_transfer_format_t *format,
<> 144:ef7eb2e8f9f7 181 uint32_t mclkSourceClockHz,
<> 144:ef7eb2e8f9f7 182 uint32_t bclkSourceClockHz)
<> 144:ef7eb2e8f9f7 183 {
<> 144:ef7eb2e8f9f7 184 assert(handle && format);
<> 144:ef7eb2e8f9f7 185
<> 144:ef7eb2e8f9f7 186 /* Configure the audio format to SAI registers */
<> 144:ef7eb2e8f9f7 187 SAI_TxSetFormat(base, format, mclkSourceClockHz, bclkSourceClockHz);
<> 144:ef7eb2e8f9f7 188
<> 144:ef7eb2e8f9f7 189 /* Get the tranfer size from format, this should be used in EDMA configuration */
<> 144:ef7eb2e8f9f7 190 handle->bytesPerFrame = format->bitWidth / 8U;
<> 144:ef7eb2e8f9f7 191
<> 144:ef7eb2e8f9f7 192 /* Update the data channel SAI used */
<> 144:ef7eb2e8f9f7 193 handle->channel = format->channel;
<> 144:ef7eb2e8f9f7 194 #if defined(FSL_FEATURE_SAI_FIFO_COUNT) && (FSL_FEATURE_SAI_FIFO_COUNT > 1)
<> 144:ef7eb2e8f9f7 195 handle->count = FSL_FEATURE_SAI_FIFO_COUNT - format->watermark;
<> 144:ef7eb2e8f9f7 196 #else
<> 144:ef7eb2e8f9f7 197 handle->count = 1U;
<> 144:ef7eb2e8f9f7 198 #endif /* FSL_FEATURE_SAI_FIFO_COUNT */
<> 144:ef7eb2e8f9f7 199 }
<> 144:ef7eb2e8f9f7 200
<> 144:ef7eb2e8f9f7 201 void SAI_TransferRxSetFormatEDMA(I2S_Type *base,
<> 144:ef7eb2e8f9f7 202 sai_edma_handle_t *handle,
<> 144:ef7eb2e8f9f7 203 sai_transfer_format_t *format,
<> 144:ef7eb2e8f9f7 204 uint32_t mclkSourceClockHz,
<> 144:ef7eb2e8f9f7 205 uint32_t bclkSourceClockHz)
<> 144:ef7eb2e8f9f7 206 {
<> 144:ef7eb2e8f9f7 207 assert(handle && format);
<> 144:ef7eb2e8f9f7 208
<> 144:ef7eb2e8f9f7 209 /* Configure the audio format to SAI registers */
<> 144:ef7eb2e8f9f7 210 SAI_RxSetFormat(base, format, mclkSourceClockHz, bclkSourceClockHz);
<> 144:ef7eb2e8f9f7 211
<> 144:ef7eb2e8f9f7 212 /* Get the tranfer size from format, this should be used in EDMA configuration */
<> 144:ef7eb2e8f9f7 213 handle->bytesPerFrame = format->bitWidth / 8U;
<> 144:ef7eb2e8f9f7 214
<> 144:ef7eb2e8f9f7 215 /* Update the data channel SAI used */
<> 144:ef7eb2e8f9f7 216 handle->channel = format->channel;
<> 144:ef7eb2e8f9f7 217
<> 144:ef7eb2e8f9f7 218 #if defined(FSL_FEATURE_SAI_FIFO_COUNT) && (FSL_FEATURE_SAI_FIFO_COUNT > 1)
<> 144:ef7eb2e8f9f7 219 handle->count = format->watermark;
<> 144:ef7eb2e8f9f7 220 #else
<> 144:ef7eb2e8f9f7 221 handle->count = 1U;
<> 144:ef7eb2e8f9f7 222 #endif /* FSL_FEATURE_SAI_FIFO_COUNT */
<> 144:ef7eb2e8f9f7 223 }
<> 144:ef7eb2e8f9f7 224
<> 144:ef7eb2e8f9f7 225 status_t SAI_TransferSendEDMA(I2S_Type *base, sai_edma_handle_t *handle, sai_transfer_t *xfer)
<> 144:ef7eb2e8f9f7 226 {
<> 144:ef7eb2e8f9f7 227 assert(handle && xfer);
<> 144:ef7eb2e8f9f7 228
<> 144:ef7eb2e8f9f7 229 edma_transfer_config_t config = {0};
<> 144:ef7eb2e8f9f7 230 uint32_t destAddr = SAI_TxGetDataRegisterAddress(base, handle->channel);
<> 144:ef7eb2e8f9f7 231
<> 144:ef7eb2e8f9f7 232 /* Check if input parameter invalid */
<> 144:ef7eb2e8f9f7 233 if ((xfer->data == NULL) || (xfer->dataSize == 0U))
<> 144:ef7eb2e8f9f7 234 {
<> 144:ef7eb2e8f9f7 235 return kStatus_InvalidArgument;
<> 144:ef7eb2e8f9f7 236 }
<> 144:ef7eb2e8f9f7 237
<> 144:ef7eb2e8f9f7 238 if (handle->saiQueue[handle->queueUser].data)
<> 144:ef7eb2e8f9f7 239 {
<> 144:ef7eb2e8f9f7 240 return kStatus_SAI_QueueFull;
<> 144:ef7eb2e8f9f7 241 }
<> 144:ef7eb2e8f9f7 242
<> 144:ef7eb2e8f9f7 243 /* Change the state of handle */
<> 144:ef7eb2e8f9f7 244 handle->state = kSAI_Busy;
<> 144:ef7eb2e8f9f7 245
<> 144:ef7eb2e8f9f7 246 /* Update the queue state */
<> 144:ef7eb2e8f9f7 247 handle->transferSize[handle->queueUser] = xfer->dataSize;
<> 144:ef7eb2e8f9f7 248 handle->saiQueue[handle->queueUser].data = xfer->data;
<> 144:ef7eb2e8f9f7 249 handle->saiQueue[handle->queueUser].dataSize = xfer->dataSize;
<> 144:ef7eb2e8f9f7 250 handle->queueUser = (handle->queueUser + 1) % SAI_XFER_QUEUE_SIZE;
<> 144:ef7eb2e8f9f7 251
<> 144:ef7eb2e8f9f7 252 /* Prepare edma configure */
<> 144:ef7eb2e8f9f7 253 EDMA_PrepareTransfer(&config, xfer->data, handle->bytesPerFrame, (void *)destAddr, handle->bytesPerFrame,
<> 144:ef7eb2e8f9f7 254 handle->count * handle->bytesPerFrame, xfer->dataSize, kEDMA_MemoryToPeripheral);
<> 144:ef7eb2e8f9f7 255
<> 144:ef7eb2e8f9f7 256 EDMA_SubmitTransfer(handle->dmaHandle, &config);
<> 144:ef7eb2e8f9f7 257
<> 144:ef7eb2e8f9f7 258 /* Start DMA transfer */
<> 144:ef7eb2e8f9f7 259 EDMA_StartTransfer(handle->dmaHandle);
<> 144:ef7eb2e8f9f7 260
<> 144:ef7eb2e8f9f7 261 /* Enable DMA enable bit */
<> 144:ef7eb2e8f9f7 262 SAI_TxEnableDMA(base, kSAI_FIFORequestDMAEnable, true);
<> 144:ef7eb2e8f9f7 263
<> 144:ef7eb2e8f9f7 264 /* Enable SAI Tx clock */
<> 144:ef7eb2e8f9f7 265 SAI_TxEnable(base, true);
<> 144:ef7eb2e8f9f7 266
<> 144:ef7eb2e8f9f7 267 return kStatus_Success;
<> 144:ef7eb2e8f9f7 268 }
<> 144:ef7eb2e8f9f7 269
<> 144:ef7eb2e8f9f7 270 status_t SAI_TransferReceiveEDMA(I2S_Type *base, sai_edma_handle_t *handle, sai_transfer_t *xfer)
<> 144:ef7eb2e8f9f7 271 {
<> 144:ef7eb2e8f9f7 272 assert(handle && xfer);
<> 144:ef7eb2e8f9f7 273
<> 144:ef7eb2e8f9f7 274 edma_transfer_config_t config = {0};
<> 144:ef7eb2e8f9f7 275 uint32_t srcAddr = SAI_RxGetDataRegisterAddress(base, handle->channel);
<> 144:ef7eb2e8f9f7 276
<> 144:ef7eb2e8f9f7 277 /* Check if input parameter invalid */
<> 144:ef7eb2e8f9f7 278 if ((xfer->data == NULL) || (xfer->dataSize == 0U))
<> 144:ef7eb2e8f9f7 279 {
<> 144:ef7eb2e8f9f7 280 return kStatus_InvalidArgument;
<> 144:ef7eb2e8f9f7 281 }
<> 144:ef7eb2e8f9f7 282
<> 144:ef7eb2e8f9f7 283 if (handle->saiQueue[handle->queueUser].data)
<> 144:ef7eb2e8f9f7 284 {
<> 144:ef7eb2e8f9f7 285 return kStatus_SAI_QueueFull;
<> 144:ef7eb2e8f9f7 286 }
<> 144:ef7eb2e8f9f7 287
<> 144:ef7eb2e8f9f7 288 /* Change the state of handle */
<> 144:ef7eb2e8f9f7 289 handle->state = kSAI_Busy;
<> 144:ef7eb2e8f9f7 290
<> 144:ef7eb2e8f9f7 291 /* Update queue state */
<> 144:ef7eb2e8f9f7 292 handle->transferSize[handle->queueUser] = xfer->dataSize;
<> 144:ef7eb2e8f9f7 293 handle->saiQueue[handle->queueUser].data = xfer->data;
<> 144:ef7eb2e8f9f7 294 handle->saiQueue[handle->queueUser].dataSize = xfer->dataSize;
<> 144:ef7eb2e8f9f7 295 handle->queueUser = (handle->queueUser + 1) % SAI_XFER_QUEUE_SIZE;
<> 144:ef7eb2e8f9f7 296
<> 144:ef7eb2e8f9f7 297 /* Prepare edma configure */
<> 144:ef7eb2e8f9f7 298 EDMA_PrepareTransfer(&config, (void *)srcAddr, handle->bytesPerFrame, xfer->data, handle->bytesPerFrame,
<> 144:ef7eb2e8f9f7 299 handle->count * handle->bytesPerFrame, xfer->dataSize, kEDMA_PeripheralToMemory);
<> 144:ef7eb2e8f9f7 300
<> 144:ef7eb2e8f9f7 301 EDMA_SubmitTransfer(handle->dmaHandle, &config);
<> 144:ef7eb2e8f9f7 302
<> 144:ef7eb2e8f9f7 303 /* Start DMA transfer */
<> 144:ef7eb2e8f9f7 304 EDMA_StartTransfer(handle->dmaHandle);
<> 144:ef7eb2e8f9f7 305
<> 144:ef7eb2e8f9f7 306 /* Enable DMA enable bit */
<> 144:ef7eb2e8f9f7 307 SAI_RxEnableDMA(base, kSAI_FIFORequestDMAEnable, true);
<> 144:ef7eb2e8f9f7 308
<> 144:ef7eb2e8f9f7 309 /* Enable SAI Rx clock */
<> 144:ef7eb2e8f9f7 310 SAI_RxEnable(base, true);
<> 144:ef7eb2e8f9f7 311
<> 144:ef7eb2e8f9f7 312 return kStatus_Success;
<> 144:ef7eb2e8f9f7 313 }
<> 144:ef7eb2e8f9f7 314
<> 144:ef7eb2e8f9f7 315 void SAI_TransferAbortSendEDMA(I2S_Type *base, sai_edma_handle_t *handle)
<> 144:ef7eb2e8f9f7 316 {
<> 144:ef7eb2e8f9f7 317 assert(handle);
<> 144:ef7eb2e8f9f7 318
<> 144:ef7eb2e8f9f7 319 /* Disable dma */
<> 144:ef7eb2e8f9f7 320 EDMA_AbortTransfer(handle->dmaHandle);
<> 144:ef7eb2e8f9f7 321
<> 144:ef7eb2e8f9f7 322 /* Disable DMA enable bit */
<> 144:ef7eb2e8f9f7 323 SAI_TxEnableDMA(base, kSAI_FIFORequestDMAEnable, false);
<> 144:ef7eb2e8f9f7 324
<> 144:ef7eb2e8f9f7 325 /* Set the handle state */
<> 144:ef7eb2e8f9f7 326 handle->state = kSAI_Idle;
<> 144:ef7eb2e8f9f7 327 }
<> 144:ef7eb2e8f9f7 328
<> 144:ef7eb2e8f9f7 329 void SAI_TransferAbortReceiveEDMA(I2S_Type *base, sai_edma_handle_t *handle)
<> 144:ef7eb2e8f9f7 330 {
<> 144:ef7eb2e8f9f7 331 assert(handle);
<> 144:ef7eb2e8f9f7 332
<> 144:ef7eb2e8f9f7 333 /* Disable dma */
<> 144:ef7eb2e8f9f7 334 EDMA_AbortTransfer(handle->dmaHandle);
<> 144:ef7eb2e8f9f7 335
<> 144:ef7eb2e8f9f7 336 /* Disable DMA enable bit */
<> 144:ef7eb2e8f9f7 337 SAI_RxEnableDMA(base, kSAI_FIFORequestDMAEnable, false);
<> 144:ef7eb2e8f9f7 338
<> 144:ef7eb2e8f9f7 339 /* Set the handle state */
<> 144:ef7eb2e8f9f7 340 handle->state = kSAI_Idle;
<> 144:ef7eb2e8f9f7 341 }
<> 144:ef7eb2e8f9f7 342
<> 144:ef7eb2e8f9f7 343 status_t SAI_TransferGetSendCountEDMA(I2S_Type *base, sai_edma_handle_t *handle, size_t *count)
<> 144:ef7eb2e8f9f7 344 {
<> 144:ef7eb2e8f9f7 345 assert(handle);
<> 144:ef7eb2e8f9f7 346
<> 144:ef7eb2e8f9f7 347 status_t status = kStatus_Success;
<> 144:ef7eb2e8f9f7 348
<> 144:ef7eb2e8f9f7 349 if (handle->state != kSAI_Busy)
<> 144:ef7eb2e8f9f7 350 {
<> 144:ef7eb2e8f9f7 351 status = kStatus_NoTransferInProgress;
<> 144:ef7eb2e8f9f7 352 }
<> 144:ef7eb2e8f9f7 353 else
<> 144:ef7eb2e8f9f7 354 {
<> 144:ef7eb2e8f9f7 355 *count = (handle->transferSize[handle->queueDriver] -
<> 144:ef7eb2e8f9f7 356 EDMA_GetRemainingBytes(handle->dmaHandle->base, handle->dmaHandle->channel));
<> 144:ef7eb2e8f9f7 357 }
<> 144:ef7eb2e8f9f7 358
<> 144:ef7eb2e8f9f7 359 return status;
<> 144:ef7eb2e8f9f7 360 }
<> 144:ef7eb2e8f9f7 361
<> 144:ef7eb2e8f9f7 362 status_t SAI_TransferGetReceiveCountEDMA(I2S_Type *base, sai_edma_handle_t *handle, size_t *count)
<> 144:ef7eb2e8f9f7 363 {
<> 144:ef7eb2e8f9f7 364 assert(handle);
<> 144:ef7eb2e8f9f7 365
<> 144:ef7eb2e8f9f7 366 status_t status = kStatus_Success;
<> 144:ef7eb2e8f9f7 367
<> 144:ef7eb2e8f9f7 368 if (handle->state != kSAI_Busy)
<> 144:ef7eb2e8f9f7 369 {
<> 144:ef7eb2e8f9f7 370 status = kStatus_NoTransferInProgress;
<> 144:ef7eb2e8f9f7 371 }
<> 144:ef7eb2e8f9f7 372 else
<> 144:ef7eb2e8f9f7 373 {
<> 144:ef7eb2e8f9f7 374 *count = (handle->transferSize[handle->queueDriver] -
<> 144:ef7eb2e8f9f7 375 EDMA_GetRemainingBytes(handle->dmaHandle->base, handle->dmaHandle->channel));
<> 144:ef7eb2e8f9f7 376 }
<> 144:ef7eb2e8f9f7 377
<> 144:ef7eb2e8f9f7 378 return status;
<> 144:ef7eb2e8f9f7 379 }