summaryrefslogtreecommitdiffstats
path: root/bsps/arm/imxrt/nxp/devices/MIMXRT1052/drivers/fsl_flexio_mculcd_edma.c
diff options
context:
space:
mode:
Diffstat (limited to 'bsps/arm/imxrt/nxp/devices/MIMXRT1052/drivers/fsl_flexio_mculcd_edma.c')
-rw-r--r--bsps/arm/imxrt/nxp/devices/MIMXRT1052/drivers/fsl_flexio_mculcd_edma.c564
1 files changed, 0 insertions, 564 deletions
diff --git a/bsps/arm/imxrt/nxp/devices/MIMXRT1052/drivers/fsl_flexio_mculcd_edma.c b/bsps/arm/imxrt/nxp/devices/MIMXRT1052/drivers/fsl_flexio_mculcd_edma.c
deleted file mode 100644
index 458ad8e72b..0000000000
--- a/bsps/arm/imxrt/nxp/devices/MIMXRT1052/drivers/fsl_flexio_mculcd_edma.c
+++ /dev/null
@@ -1,564 +0,0 @@
-/*
- * Copyright (c) 2016, Freescale Semiconductor, Inc.
- * Copyright 2016-2019 NXP
- * All rights reserved.
- *
- * SPDX-License-Identifier: BSD-3-Clause
- */
-
-#include "fsl_flexio_mculcd_edma.h"
-
-/*******************************************************************************
- * Definitions
- ******************************************************************************/
-
-/* Component ID definition, used by tools. */
-#ifndef FSL_COMPONENT_ID
-#define FSL_COMPONENT_ID "platform.drivers.flexio_mculcd_edma"
-#endif
-
-#define EDMA_MAX_MAJOR_COUNT (DMA_CITER_ELINKNO_CITER_MASK >> DMA_CITER_ELINKNO_CITER_SHIFT)
-
-enum
-{
- kFLEXIO_MCULCD_StateIdle, /*!< No transfer in progress. */
- kFLEXIO_MCULCD_StateReadArray, /*!< Reading array in progress. */
- kFLEXIO_MCULCD_StateWriteArray, /*!< Writing array in progress. */
- kFLEXIO_MCULCD_StateWriteSameValue, /*!< Writing the same value in progress.
- */
-};
-
-/*******************************************************************************
- * Prototypes
- ******************************************************************************/
-
-/*!
- * @brief EDMA callback function for FLEXIO MCULCD TX.
- *
- * For details, see @ref edma_callback.
- */
-static void FLEXIO_MCULCD_TxEDMACallback(edma_handle_t *DmaHandle, void *param, bool transferDone, uint32_t tcds);
-
-/*!
- * @brief EDMA callback function for FLEXIO MCULCD RX.
- *
- * For details, see @ref edma_callback.
- */
-static void FLEXIO_MCULCD_RxEDMACallback(edma_handle_t *DmaHandle, void *param, bool transferDone, uint32_t tcds);
-
-/*!
- * @brief Set EDMA config for FLEXIO MCULCD transfer.
- *
- * @param base pointer to FLEXIO_MCULCD_Type structure.
- * @param handle pointer to flexio_mculcd_edma_handle_t structure to store the
- * transfer state.
- */
-static void FLEXIO_MCULCD_EDMAConfig(FLEXIO_MCULCD_Type *base, flexio_mculcd_edma_handle_t *handle);
-
-/*!
- * @brief Convert the FlexIO shifter number to eDMA modulo.
- *
- * @param shifterNum The FlexIO shifter number.
- * @param modulo The modulo number.
- * @retval Get the modulo successfully.
- * @retval Could not get the modulo for the shifter number.
- */
-static bool FLEXIO_MCULCD_GetEDMAModulo(uint8_t shifterNum, edma_modulo_t *modulo);
-
-/*******************************************************************************
- * Variables
- ******************************************************************************/
-
-/*******************************************************************************
- * Code
- ******************************************************************************/
-
-static void FLEXIO_MCULCD_TxEDMACallback(edma_handle_t *DmaHandle, void *param, bool transferDone, uint32_t tcds)
-{
- tcds = tcds;
- flexio_mculcd_edma_handle_t *flexioLcdMcuHandle = (flexio_mculcd_edma_handle_t *)param;
- FLEXIO_MCULCD_Type *flexioLcdMcuBase = flexioLcdMcuHandle->base;
-
- if (transferDone)
- {
- if (flexioLcdMcuHandle->remainingCount >= flexioLcdMcuHandle->minorLoopBytes)
- {
- FLEXIO_MCULCD_EDMAConfig(flexioLcdMcuBase, flexioLcdMcuHandle);
- EDMA_StartTransfer(flexioLcdMcuHandle->txDmaHandle);
- }
- else
- {
- FLEXIO_MCULCD_EnableTxDMA(flexioLcdMcuBase, false);
-
- /* Now the data are in shifter, wait for the data send out from the shifter. */
- FLEXIO_MCULCD_WaitTransmitComplete();
-
- /* Disable the TX shifter and the timer. */
- FLEXIO_MCULCD_ClearMultiBeatsWriteConfig(flexioLcdMcuBase);
-
- /* Send the remaining data. */
- if (0U != flexioLcdMcuHandle->remainingCount)
- {
- if ((uint32_t)kFLEXIO_MCULCD_StateWriteSameValue == flexioLcdMcuHandle->state)
- {
- FLEXIO_MCULCD_WriteSameValueBlocking(flexioLcdMcuBase, flexioLcdMcuHandle->dataAddrOrSameValue,
- flexioLcdMcuHandle->remainingCount);
- }
- else
- {
- FLEXIO_MCULCD_WriteDataArrayBlocking(flexioLcdMcuBase,
- (uint8_t *)flexioLcdMcuHandle->dataAddrOrSameValue,
- flexioLcdMcuHandle->remainingCount);
- }
- }
-
- /* De-assert nCS. */
- FLEXIO_MCULCD_StopTransfer(flexioLcdMcuBase);
-
- /* Change the state. */
- flexioLcdMcuHandle->state = (uint32_t)kFLEXIO_MCULCD_StateIdle;
- flexioLcdMcuHandle->dataCount = 0;
- flexioLcdMcuHandle->remainingCount = 0;
-
- /* Callback to inform upper layer. */
- if (NULL != flexioLcdMcuHandle->completionCallback)
- {
- flexioLcdMcuHandle->completionCallback(flexioLcdMcuBase, flexioLcdMcuHandle, kStatus_FLEXIO_MCULCD_Idle,
- flexioLcdMcuHandle->userData);
- }
- }
- }
-}
-
-static void FLEXIO_MCULCD_RxEDMACallback(edma_handle_t *DmaHandle, void *param, bool transferDone, uint32_t tcds)
-{
- tcds = tcds;
- uint32_t i;
- uint32_t rxBufAddr;
- flexio_mculcd_edma_handle_t *flexioLcdMcuHandle = (flexio_mculcd_edma_handle_t *)param;
- FLEXIO_MCULCD_Type *flexioLcdMcuBase = flexioLcdMcuHandle->base;
- FLEXIO_Type *flexioBase = flexioLcdMcuBase->flexioBase;
-
- if (transferDone)
- {
- if (flexioLcdMcuHandle->remainingCount >= (2U * flexioLcdMcuHandle->minorLoopBytes))
- {
- FLEXIO_MCULCD_EDMAConfig(flexioLcdMcuBase, flexioLcdMcuHandle);
- EDMA_StartTransfer(flexioLcdMcuHandle->rxDmaHandle);
- }
- else
- {
- FLEXIO_MCULCD_EnableRxDMA(flexioLcdMcuBase, false);
-
- /* Wait the data saved to the shifter buffer. */
- while (0U == ((1UL << flexioLcdMcuBase->rxShifterEndIndex) & FLEXIO_GetShifterStatusFlags(flexioBase)))
- {
- }
-
- /* Disable the RX shifter and the timer. */
- FLEXIO_MCULCD_ClearMultiBeatsReadConfig(flexioLcdMcuBase);
-
- rxBufAddr = FLEXIO_MCULCD_GetRxDataRegisterAddress(flexioLcdMcuBase);
-
-/* Read out the data. */
-#if (defined(__CORTEX_M) && (__CORTEX_M == 0))
- /* Cortex M0 and M0+ only support aligned access. */
- for (i = 0; i < flexioLcdMcuHandle->rxShifterNum * 4; i++)
- {
- ((uint8_t *)(flexioLcdMcuHandle->dataAddrOrSameValue))[i] = ((volatile uint8_t *)rxBufAddr)[i];
- }
-#else
- for (i = 0; i < flexioLcdMcuHandle->rxShifterNum; i++)
- {
- ((uint32_t *)(flexioLcdMcuHandle->dataAddrOrSameValue))[i] = ((volatile uint32_t *)rxBufAddr)[i];
- }
-#endif
- flexioLcdMcuHandle->remainingCount -= flexioLcdMcuHandle->minorLoopBytes;
-
- if (0U != flexioLcdMcuHandle->remainingCount)
- {
- FLEXIO_MCULCD_ReadDataArrayBlocking(
- flexioLcdMcuBase,
- (uint8_t *)(flexioLcdMcuHandle->dataAddrOrSameValue + flexioLcdMcuHandle->minorLoopBytes),
- flexioLcdMcuHandle->remainingCount);
- }
-
- /* De-assert nCS. */
- FLEXIO_MCULCD_StopTransfer(flexioLcdMcuBase);
-
- /* Change the state. */
- flexioLcdMcuHandle->state = (uint32_t)kFLEXIO_MCULCD_StateIdle;
- flexioLcdMcuHandle->dataCount = 0;
- flexioLcdMcuHandle->remainingCount = 0;
-
- /* Callback to inform upper layer. */
- if (NULL != flexioLcdMcuHandle->completionCallback)
- {
- flexioLcdMcuHandle->completionCallback(flexioLcdMcuBase, flexioLcdMcuHandle, kStatus_FLEXIO_MCULCD_Idle,
- flexioLcdMcuHandle->userData);
- }
- }
- }
-}
-
-static void FLEXIO_MCULCD_EDMAConfig(FLEXIO_MCULCD_Type *base, flexio_mculcd_edma_handle_t *handle)
-{
- edma_transfer_config_t xferConfig = {0};
- edma_transfer_size_t transferSize = kEDMA_TransferSize1Bytes;
- int16_t offset;
- uint32_t majorLoopCounts;
- uint32_t transferCount;
-
-#if (8 == FLEXIO_MCULCD_DATA_BUS_WIDTH)
- transferSize = kEDMA_TransferSize1Bytes;
- offset = 1;
-#else
- transferSize = kEDMA_TransferSize2Bytes;
- offset = 2;
-#endif
-
- majorLoopCounts = handle->remainingCount / handle->minorLoopBytes;
-
- /* For reading, the last minor loop data is not tranfered by DMA. */
- if ((uint32_t)kFLEXIO_MCULCD_StateReadArray == handle->state)
- {
- majorLoopCounts--;
- }
-
- if (majorLoopCounts > EDMA_MAX_MAJOR_COUNT)
- {
- majorLoopCounts = EDMA_MAX_MAJOR_COUNT;
- }
-
- transferCount = majorLoopCounts * handle->minorLoopBytes;
-
- if ((uint32_t)kFLEXIO_MCULCD_StateReadArray == handle->state)
- {
- xferConfig.srcAddr = FLEXIO_MCULCD_GetRxDataRegisterAddress(base);
- xferConfig.destAddr = handle->dataAddrOrSameValue;
- xferConfig.srcTransferSize = kEDMA_TransferSize4Bytes;
- xferConfig.destTransferSize = transferSize;
- xferConfig.srcOffset = 4;
- xferConfig.destOffset = offset;
- xferConfig.minorLoopBytes = handle->minorLoopBytes;
- xferConfig.majorLoopCounts = majorLoopCounts;
- handle->remainingCount -= transferCount;
- handle->dataAddrOrSameValue += transferCount;
- (void)EDMA_SubmitTransfer(handle->rxDmaHandle, &xferConfig);
- EDMA_SetModulo(handle->rxDmaHandle->base, handle->rxDmaHandle->channel, handle->rxEdmaModulo,
- kEDMA_ModuloDisable);
- }
- else
- {
- if ((uint32_t)kFLEXIO_MCULCD_StateWriteArray == handle->state)
- {
- xferConfig.srcAddr = handle->dataAddrOrSameValue;
- xferConfig.srcOffset = offset;
- handle->dataAddrOrSameValue += transferCount;
- }
- else
- {
- xferConfig.srcAddr = (uint32_t)(&(handle->dataAddrOrSameValue));
- xferConfig.srcOffset = 0;
- }
- xferConfig.destAddr = FLEXIO_MCULCD_GetTxDataRegisterAddress(base);
- xferConfig.srcTransferSize = transferSize;
- xferConfig.destTransferSize = kEDMA_TransferSize4Bytes;
- xferConfig.destOffset = 4;
- xferConfig.minorLoopBytes = handle->minorLoopBytes;
- xferConfig.majorLoopCounts = majorLoopCounts;
- handle->remainingCount -= transferCount;
- (void)EDMA_SubmitTransfer(handle->txDmaHandle, &xferConfig);
- EDMA_SetModulo(handle->txDmaHandle->base, handle->txDmaHandle->channel, kEDMA_ModuloDisable,
- handle->txEdmaModulo);
- }
-}
-
-static bool FLEXIO_MCULCD_GetEDMAModulo(uint8_t shifterNum, edma_modulo_t *modulo)
-{
- bool ret = true;
-
- switch (shifterNum)
- {
- case 1U:
- *modulo = kEDMA_Modulo4bytes;
- break;
- case 2U:
- *modulo = kEDMA_Modulo8bytes;
- break;
- case 4U:
- *modulo = kEDMA_Modulo16bytes;
- break;
- case 8U:
- *modulo = kEDMA_Modulo32bytes;
- break;
- default:
- ret = false;
- break;
- }
-
- return ret;
-}
-
-/*!
- * brief Initializes the FLEXO MCULCD master eDMA handle.
- *
- * This function initializes the FLEXO MCULCD master eDMA handle which can be
- * used for other FLEXO MCULCD transactional APIs. For a specified FLEXO MCULCD
- * instance, call this API once to get the initialized handle.
- *
- * param base Pointer to FLEXIO_MCULCD_Type structure.
- * param handle Pointer to flexio_mculcd_edma_handle_t structure to store the
- * transfer state.
- * param callback MCULCD transfer complete callback, NULL means no callback.
- * param userData callback function parameter.
- * param txDmaHandle User requested eDMA handle for FlexIO MCULCD eDMA TX,
- * the DMA request source of this handle should be the first of TX shifters.
- * param rxDmaHandle User requested eDMA handle for FlexIO MCULCD eDMA RX,
- * the DMA request source of this handle should be the last of RX shifters.
- * retval kStatus_Success Successfully create the handle.
- */
-status_t FLEXIO_MCULCD_TransferCreateHandleEDMA(FLEXIO_MCULCD_Type *base,
- flexio_mculcd_edma_handle_t *handle,
- flexio_mculcd_edma_transfer_callback_t callback,
- void *userData,
- edma_handle_t *txDmaHandle,
- edma_handle_t *rxDmaHandle)
-{
- assert(NULL != handle);
-
- /* Zero the handle. */
- (void)memset(handle, 0, sizeof(*handle));
-
- /* Initialize the state. */
- handle->state = (uint32_t)kFLEXIO_MCULCD_StateIdle;
-
- /* Register callback and userData. */
- handle->completionCallback = callback;
- handle->userData = userData;
-
- handle->base = base;
- handle->txShifterNum = base->txShifterEndIndex - base->txShifterStartIndex + 1U;
- handle->rxShifterNum = base->rxShifterEndIndex - base->rxShifterStartIndex + 1U;
-
- if (NULL != rxDmaHandle)
- {
- if (!FLEXIO_MCULCD_GetEDMAModulo(handle->rxShifterNum, &handle->rxEdmaModulo))
- {
- return kStatus_InvalidArgument;
- }
-
- handle->rxDmaHandle = rxDmaHandle;
- EDMA_SetCallback(rxDmaHandle, FLEXIO_MCULCD_RxEDMACallback, handle);
- }
-
- if (NULL != txDmaHandle)
- {
- if (!FLEXIO_MCULCD_GetEDMAModulo(handle->txShifterNum, &handle->txEdmaModulo))
- {
- return kStatus_InvalidArgument;
- }
-
- handle->txDmaHandle = txDmaHandle;
- EDMA_SetCallback(txDmaHandle, FLEXIO_MCULCD_TxEDMACallback, handle);
- }
-
- return kStatus_Success;
-}
-
-/*!
- * brief Performs a non-blocking FlexIO MCULCD transfer using eDMA.
- *
- * This function returns immediately after transfer initiates. To check whether
- * the transfer is completed, user could:
- * 1. Use the transfer completed callback;
- * 2. Polling function ref FLEXIO_MCULCD_GetTransferCountEDMA
- *
- * param base pointer to FLEXIO_MCULCD_Type structure.
- * param handle pointer to flexio_mculcd_edma_handle_t structure to store the
- * transfer state.
- * param xfer Pointer to FlexIO MCULCD transfer structure.
- * retval kStatus_Success Successfully start a transfer.
- * retval kStatus_InvalidArgument Input argument is invalid.
- * retval kStatus_FLEXIO_MCULCD_Busy FlexIO MCULCD is not idle, it is running another
- * transfer.
- */
-status_t FLEXIO_MCULCD_TransferEDMA(FLEXIO_MCULCD_Type *base,
- flexio_mculcd_edma_handle_t *handle,
- flexio_mculcd_transfer_t *xfer)
-{
- assert(NULL != handle);
- assert(NULL != xfer);
-
- /*
- * The data transfer mechanism:
- *
- * Read:
- * Assume the data length is Lr = (n1 * minorLoopBytes + n2), where
- * n2 < minorLoopBytes.
- * If (n1 <= 1), then all data are sent using blocking method.
- * If (n1 > 1), then the beginning ((n1-1) * minorLoopBytes) are read
- * using DMA, the left (minorLoopBytes + n2) are read using blocking method.
- *
- * Write:
- * Assume the data length is Lw = (n1 * minorLoopBytes + n2), where
- * n2 < minorLoopBytes.
- * If (n1 = 0), then all data are sent using blocking method.
- * If (n1 >= 1), then the beginning (n1 * minorLoopBytes) are sent
- * using DMA, the left n2 are sent using blocking method.
- */
-
- /* Check if the device is busy. */
- if ((uint32_t)kFLEXIO_MCULCD_StateIdle != handle->state)
- {
- return kStatus_FLEXIO_MCULCD_Busy;
- }
-
- /* Set the state in handle. */
- if (kFLEXIO_MCULCD_ReadArray == xfer->mode)
- {
- handle->state = (uint32_t)kFLEXIO_MCULCD_StateReadArray;
- handle->minorLoopBytes = handle->rxShifterNum * 4UL;
- }
- else
- {
- handle->minorLoopBytes = handle->txShifterNum * 4UL;
-
- if (kFLEXIO_MCULCD_WriteArray == xfer->mode)
- {
- handle->state = (uint32_t)kFLEXIO_MCULCD_StateWriteArray;
- }
- else
- {
- handle->state = (uint32_t)kFLEXIO_MCULCD_StateWriteSameValue;
- }
- }
-
- /*
- * For TX, if data is less than one minor loop, then use polling method.
- * For RX, if data is less than two minor loop, then use polling method.
- */
- if ((xfer->dataSize < handle->minorLoopBytes) ||
- ((kFLEXIO_MCULCD_ReadArray == xfer->mode) && (xfer->dataSize < 2U * (handle->minorLoopBytes))))
- {
- FLEXIO_MCULCD_TransferBlocking(base, xfer);
-
- handle->state = (uint32_t)kFLEXIO_MCULCD_StateIdle;
-
- /* Callback to inform upper layer. */
- if (NULL != handle->completionCallback)
- {
- handle->completionCallback(base, handle, kStatus_FLEXIO_MCULCD_Idle, handle->userData);
- }
- }
- else
- {
- handle->dataCount = xfer->dataSize;
- handle->remainingCount = xfer->dataSize;
- handle->dataAddrOrSameValue = xfer->dataAddrOrSameValue;
-
- /* Setup DMA to transfer data. */
- /* Assert the nCS. */
- FLEXIO_MCULCD_StartTransfer(base);
- /* Send the command. */
- FLEXIO_MCULCD_WriteCommandBlocking(base, xfer->command);
-
- /* Setup the DMA configuration. */
- FLEXIO_MCULCD_EDMAConfig(base, handle);
-
- /* Start the transfer. */
- if (kFLEXIO_MCULCD_ReadArray == xfer->mode)
- {
- /* For 6800, assert the RDWR pin. */
- if (kFLEXIO_MCULCD_6800 == base->busType)
- {
- base->setRDWRPin(true);
- }
- FLEXIO_MCULCD_SetMultiBeatsReadConfig(base);
- FLEXIO_MCULCD_EnableRxDMA(base, true);
- EDMA_StartTransfer(handle->rxDmaHandle);
- }
- else
- {
- /* For 6800, de-assert the RDWR pin. */
- if (kFLEXIO_MCULCD_6800 == base->busType)
- {
- base->setRDWRPin(false);
- }
- FLEXIO_MCULCD_SetMultiBeatsWriteConfig(base);
- FLEXIO_MCULCD_EnableTxDMA(base, true);
- EDMA_StartTransfer(handle->txDmaHandle);
- }
- }
-
- return kStatus_Success;
-}
-
-/*!
- * brief Aborts a FlexIO MCULCD transfer using eDMA.
- *
- * param base pointer to FLEXIO_MCULCD_Type structure.
- * param handle FlexIO MCULCD eDMA handle pointer.
- */
-void FLEXIO_MCULCD_TransferAbortEDMA(FLEXIO_MCULCD_Type *base, flexio_mculcd_edma_handle_t *handle)
-{
- assert(NULL != handle);
-
- /* Disable dma. */
- if (NULL != handle->txDmaHandle)
- {
- EDMA_AbortTransfer(handle->txDmaHandle);
- }
- if (NULL != handle->rxDmaHandle)
- {
- EDMA_AbortTransfer(handle->rxDmaHandle);
- }
-
- /* Disable DMA enable bit. */
- FLEXIO_MCULCD_EnableTxDMA(handle->base, false);
- FLEXIO_MCULCD_EnableRxDMA(handle->base, false);
-
- /* Set the handle state. */
- handle->state = (uint32_t)kFLEXIO_MCULCD_StateIdle;
- handle->dataCount = 0;
-}
-
-/*!
- * brief Gets the remaining bytes for FlexIO MCULCD eDMA transfer.
- *
- * param base pointer to FLEXIO_MCULCD_Type structure.
- * param handle FlexIO MCULCD eDMA handle pointer.
- * param count Number of count transferred so far by the eDMA transaction.
- * retval kStatus_Success Get the transferred count Successfully.
- * retval kStatus_NoTransferInProgress No transfer in process.
- */
-status_t FLEXIO_MCULCD_TransferGetCountEDMA(FLEXIO_MCULCD_Type *base,
- flexio_mculcd_edma_handle_t *handle,
- size_t *count)
-{
- assert(NULL != handle);
- assert(NULL != count);
- uint32_t state = handle->state;
-
- if ((uint32_t)kFLEXIO_MCULCD_StateIdle == state)
- {
- return kStatus_NoTransferInProgress;
- }
- else
- {
- *count = handle->dataCount - handle->remainingCount;
-
- if ((uint32_t)kFLEXIO_MCULCD_StateReadArray == state)
- {
- *count -= handle->minorLoopBytes *
- EDMA_GetRemainingMajorLoopCount(handle->rxDmaHandle->base, handle->rxDmaHandle->channel);
- }
- else
- {
- *count -= handle->minorLoopBytes *
- EDMA_GetRemainingMajorLoopCount(handle->txDmaHandle->base, handle->txDmaHandle->channel);
- }
- }
-
- return kStatus_Success;
-}