Lpspi_edma_driver

Data Structures
struct	_lpspi_master_edma_handle
	LPSPI master eDMA transfer handle structure used for transactional API. More...
struct	_lpspi_slave_edma_handle
	LPSPI slave eDMA transfer handle structure used for transactional API. More...

Variables
volatile bool	_lpspi_master_edma_handle::isPcsContinuous
volatile bool	_lpspi_master_edma_handle::isByteSwap
volatile uint8_t	_lpspi_master_edma_handle::fifoSize
volatile uint8_t	_lpspi_master_edma_handle::rxWatermark
volatile uint8_t	_lpspi_master_edma_handle::bytesEachWrite
volatile uint8_t	_lpspi_master_edma_handle::bytesEachRead
volatile uint8_t	_lpspi_master_edma_handle::bytesLastRead
volatile uint8_t	_lpspi_master_edma_handle::isThereExtraRxBytes
uint8_t *volatile	_lpspi_master_edma_handle::txData
uint8_t *volatile	_lpspi_master_edma_handle::rxData
volatile size_t	_lpspi_master_edma_handle::txRemainingByteCount
volatile size_t	_lpspi_master_edma_handle::rxRemainingByteCount
volatile uint32_t	_lpspi_master_edma_handle::writeRegRemainingTimes
volatile uint32_t	_lpspi_master_edma_handle::readRegRemainingTimes
uint32_t	_lpspi_master_edma_handle::totalByteCount
uint32_t	_lpspi_master_edma_handle::txBuffIfNull
uint32_t	_lpspi_master_edma_handle::rxBuffIfNull
uint32_t	_lpspi_master_edma_handle::transmitCommand
volatile uint8_t	_lpspi_master_edma_handle::state
uint8_t	_lpspi_master_edma_handle::nbytes
lpspi_master_edma_transfer_callback_t	_lpspi_master_edma_handle::callback
void *	_lpspi_master_edma_handle::userData
edma_handle_t *	_lpspi_master_edma_handle::edmaRxRegToRxDataHandle
edma_handle_t *	_lpspi_master_edma_handle::edmaTxDataToTxRegHandle
edma_tcd_t	_lpspi_master_edma_handle::lpspiSoftwareTCD [3]
volatile bool	_lpspi_slave_edma_handle::isByteSwap
volatile uint8_t	_lpspi_slave_edma_handle::fifoSize
volatile uint8_t	_lpspi_slave_edma_handle::rxWatermark
volatile uint8_t	_lpspi_slave_edma_handle::bytesEachWrite
volatile uint8_t	_lpspi_slave_edma_handle::bytesEachRead
volatile uint8_t	_lpspi_slave_edma_handle::bytesLastRead
volatile uint8_t	_lpspi_slave_edma_handle::isThereExtraRxBytes
uint8_t	_lpspi_slave_edma_handle::nbytes
uint8_t *volatile	_lpspi_slave_edma_handle::txData
uint8_t *volatile	_lpspi_slave_edma_handle::rxData
volatile size_t	_lpspi_slave_edma_handle::txRemainingByteCount
volatile size_t	_lpspi_slave_edma_handle::rxRemainingByteCount
volatile uint32_t	_lpspi_slave_edma_handle::writeRegRemainingTimes
volatile uint32_t	_lpspi_slave_edma_handle::readRegRemainingTimes
uint32_t	_lpspi_slave_edma_handle::totalByteCount
uint32_t	_lpspi_slave_edma_handle::txBuffIfNull
uint32_t	_lpspi_slave_edma_handle::rxBuffIfNull
volatile uint8_t	_lpspi_slave_edma_handle::state
uint32_t	_lpspi_slave_edma_handle::errorCount
lpspi_slave_edma_transfer_callback_t	_lpspi_slave_edma_handle::callback
void *	_lpspi_slave_edma_handle::userData
edma_handle_t *	_lpspi_slave_edma_handle::edmaRxRegToRxDataHandle
edma_handle_t *	_lpspi_slave_edma_handle::edmaTxDataToTxRegHandle
edma_tcd_t	_lpspi_slave_edma_handle::lpspiSoftwareTCD [2]

Driver version
typedef struct _lpspi_master_edma_handle	lpspi_master_edma_handle_t
	Forward declaration of the _lpspi_master_edma_handle typedefs.
typedef struct _lpspi_slave_edma_handle	lpspi_slave_edma_handle_t
	Forward declaration of the _lpspi_slave_edma_handle typedefs.
typedef void(*	lpspi_master_edma_transfer_callback_t) (LPSPI_Type *base, lpspi_master_edma_handle_t *handle, status_t status, void *userData)
	Completion callback function pointer type.
typedef void(*	lpspi_slave_edma_transfer_callback_t) (LPSPI_Type *base, lpspi_slave_edma_handle_t *handle, status_t status, void *userData)
	Completion callback function pointer type.
void	LPSPI_MasterTransferCreateHandleEDMA (LPSPI_Type *base, lpspi_master_edma_handle_t *handle, lpspi_master_edma_transfer_callback_t callback, void *userData, edma_handle_t *edmaRxRegToRxDataHandle, edma_handle_t *edmaTxDataToTxRegHandle)
	Initializes the LPSPI master eDMA handle.
status_t	LPSPI_MasterTransferEDMA (LPSPI_Type *base, lpspi_master_edma_handle_t *handle, lpspi_transfer_t *transfer)
	LPSPI master transfer data using eDMA.
void	LPSPI_MasterTransferAbortEDMA (LPSPI_Type *base, lpspi_master_edma_handle_t *handle)
	LPSPI master aborts a transfer which is using eDMA.
status_t	LPSPI_MasterTransferGetCountEDMA (LPSPI_Type *base, lpspi_master_edma_handle_t *handle, size_t *count)
	Gets the master eDMA transfer remaining bytes.
void	LPSPI_SlaveTransferCreateHandleEDMA (LPSPI_Type *base, lpspi_slave_edma_handle_t *handle, lpspi_slave_edma_transfer_callback_t callback, void *userData, edma_handle_t *edmaRxRegToRxDataHandle, edma_handle_t *edmaTxDataToTxRegHandle)
	Initializes the LPSPI slave eDMA handle.
status_t	LPSPI_SlaveTransferEDMA (LPSPI_Type *base, lpspi_slave_edma_handle_t *handle, lpspi_transfer_t *transfer)
	LPSPI slave transfers data using eDMA.
void	LPSPI_SlaveTransferAbortEDMA (LPSPI_Type *base, lpspi_slave_edma_handle_t *handle)
	LPSPI slave aborts a transfer which is using eDMA.
status_t	LPSPI_SlaveTransferGetCountEDMA (LPSPI_Type *base, lpspi_slave_edma_handle_t *handle, size_t *count)
	Gets the slave eDMA transfer remaining bytes.

Detailed Description

Typedef Documentation

lpspi_master_edma_handle_t

typedef struct _lpspi_master_edma_handle lpspi_master_edma_handle_t

Forward declaration of the _lpspi_master_edma_handle typedefs.

Definition at line 31 of file fsl_lpspi_edma.h.

lpspi_master_edma_transfer_callback_t

typedef void(* lpspi_master_edma_transfer_callback_t) (LPSPI_Type *base, lpspi_master_edma_handle_t *handle, status_t status, void *userData)

Completion callback function pointer type.

Parameters

base	LPSPI peripheral base address.
handle	Pointer to the handle for the LPSPI master.
status	Success or error code describing whether the transfer completed.
userData	Arbitrary pointer-dataSized value passed from the application.

Definition at line 46 of file fsl_lpspi_edma.h.

lpspi_slave_edma_handle_t

typedef struct _lpspi_slave_edma_handle lpspi_slave_edma_handle_t

Forward declaration of the _lpspi_slave_edma_handle typedefs.

Definition at line 36 of file fsl_lpspi_edma.h.

lpspi_slave_edma_transfer_callback_t

typedef void(* lpspi_slave_edma_transfer_callback_t) (LPSPI_Type *base, lpspi_slave_edma_handle_t *handle, status_t status, void *userData)

Completion callback function pointer type.

Parameters

base	LPSPI peripheral base address.
handle	Pointer to the handle for the LPSPI slave.
status	Success or error code describing whether the transfer completed.
userData	Arbitrary pointer-dataSized value passed from the application.

Definition at line 58 of file fsl_lpspi_edma.h.

Function Documentation

LPSPI_MasterTransferAbortEDMA()

void LPSPI_MasterTransferAbortEDMA	(	LPSPI_Type *	base,
		lpspi_master_edma_handle_t *	handle
	)

LPSPI master aborts a transfer which is using eDMA.

This function aborts a transfer which is using eDMA.

Parameters

base	LPSPI peripheral base address.
handle	pointer to lpspi_master_edma_handle_t structure which stores the transfer state.

brief LPSPI master aborts a transfer which is using eDMA.

This function aborts a transfer which is using eDMA.

param base LPSPI peripheral base address. param handle pointer to lpspi_master_edma_handle_t structure which stores the transfer state.

Definition at line 631 of file fsl_lpspi_edma.c.

{
    assert(handle);
 
    LPSPI_DisableDMA(base, kLPSPI_RxDmaEnable | kLPSPI_TxDmaEnable);
 
    EDMA_AbortTransfer(handle->edmaRxRegToRxDataHandle);
    EDMA_AbortTransfer(handle->edmaTxDataToTxRegHandle);
 
    handle->state = kLPSPI_Idle;
}

Here is the call graph for this function:

LPSPI_MasterTransferCreateHandleEDMA()

void LPSPI_MasterTransferCreateHandleEDMA	(	LPSPI_Type *	base,
		lpspi_master_edma_handle_t *	handle,
		lpspi_master_edma_transfer_callback_t	callback,
		void *	userData,
		edma_handle_t *	edmaRxRegToRxDataHandle,
		edma_handle_t *	edmaTxDataToTxRegHandle
	)

Initializes the LPSPI master eDMA handle.

This function initializes the LPSPI eDMA handle which can be used for other LPSPI transactional APIs. Usually, for a specified LPSPI instance, call this API once to get the initialized handle.

Note that the LPSPI eDMA has a separated (Rx and Rx as two sources) or shared (Rx and Tx are the same source) DMA request source. (1) For a separated DMA request source, enable and set the Rx DMAMUX source for edmaRxRegToRxDataHandle and Tx DMAMUX source for edmaIntermediaryToTxRegHandle. (2) For a shared DMA request source, enable and set the Rx/Rx DMAMUX source for edmaRxRegToRxDataHandle.

Parameters

base	LPSPI peripheral base address.
handle	LPSPI handle pointer to lpspi_master_edma_handle_t.
callback	LPSPI callback.
userData	callback function parameter.
edmaRxRegToRxDataHandle	edmaRxRegToRxDataHandle pointer to edma_handle_t.
edmaTxDataToTxRegHandle	edmaTxDataToTxRegHandle pointer to edma_handle_t.

brief Initializes the LPSPI master eDMA handle.

This function initializes the LPSPI eDMA handle which can be used for other LPSPI transactional APIs. Usually, for a specified LPSPI instance, call this API once to get the initialized handle.

Note that the LPSPI eDMA has a separated (Rx and Rx as two sources) or shared (Rx and Tx are the same source) DMA request source. (1) For a separated DMA request source, enable and set the Rx DMAMUX source for edmaRxRegToRxDataHandle and Tx DMAMUX source for edmaIntermediaryToTxRegHandle. (2) For a shared DMA request source, enable and set the Rx/Rx DMAMUX source for edmaRxRegToRxDataHandle.

param base LPSPI peripheral base address. param handle LPSPI handle pointer to lpspi_master_edma_handle_t. param callback LPSPI callback. param userData callback function parameter. param edmaRxRegToRxDataHandle edmaRxRegToRxDataHandle pointer to edma_handle_t. param edmaTxDataToTxRegHandle edmaTxDataToTxRegHandle pointer to edma_handle_t.

Definition at line 177 of file fsl_lpspi_edma.c.

{
    assert(handle);
    assert(edmaRxRegToRxDataHandle);
    assert(edmaTxDataToTxRegHandle);
 
    /* Zero the handle. */
    memset(handle, 0, sizeof(*handle));
 
    uint32_t instance = LPSPI_GetInstance(base);
 
    s_lpspiMasterEdmaPrivateHandle[instance].base = base;
    s_lpspiMasterEdmaPrivateHandle[instance].handle = handle;
 
    handle->callback = callback;
    handle->userData = userData;
 
    handle->edmaRxRegToRxDataHandle = edmaRxRegToRxDataHandle;
    handle->edmaTxDataToTxRegHandle = edmaTxDataToTxRegHandle;
}

Here is the call graph for this function:

LPSPI_MasterTransferEDMA()

status_t LPSPI_MasterTransferEDMA	(	LPSPI_Type *	base,
		lpspi_master_edma_handle_t *	handle,
		lpspi_transfer_t *	transfer
	)

LPSPI master transfer data using eDMA.

This function transfers data using eDMA. This is a non-blocking function, which returns right away. When all data is transferred, the callback function is called.

Note: The transfer data size should be an integer multiple of bytesPerFrame if bytesPerFrame is less than or equal to 4. For bytesPerFrame greater than 4: The transfer data size should be equal to bytesPerFrame if the bytesPerFrame is not an integer multiple of 4. Otherwise, the transfer data size can be an integer multiple of bytesPerFrame.

Parameters

base	LPSPI peripheral base address.
handle	pointer to lpspi_master_edma_handle_t structure which stores the transfer state.
transfer	pointer to lpspi_transfer_t structure.

Returns

status of status_t.

brief LPSPI master transfer data using eDMA.

This function transfers data using eDMA. This is a non-blocking function, which returns right away. When all data is transferred, the callback function is called.

Note: The transfer data size should be an integer multiple of bytesPerFrame if bytesPerFrame is less than or equal to 4. For bytesPerFrame greater than 4: The transfer data size should be equal to bytesPerFrame if the bytesPerFrame is not an integer multiple of 4. Otherwise, the transfer data size can be an integer multiple of bytesPerFrame.

param base LPSPI peripheral base address. param handle pointer to lpspi_master_edma_handle_t structure which stores the transfer state. param transfer pointer to lpspi_transfer_t structure. return status of status_t.

Definition at line 220 of file fsl_lpspi_edma.c.

{
    assert(handle);
    assert(transfer);
 
    uint32_t bitsPerFrame = ((base->TCR & LPSPI_TCR_FRAMESZ_MASK) >> LPSPI_TCR_FRAMESZ_SHIFT) + 1;
    uint32_t bytesPerFrame = (bitsPerFrame + 7) / 8;
    uint32_t temp = 0U;
 
    if (!LPSPI_CheckTransferArgument(transfer, bitsPerFrame, bytesPerFrame))
    {
        return kStatus_InvalidArgument;
    }
 
    /*And since the dma transfer can not support 3 bytes .*/
    if ((bytesPerFrame % 4U) == 3)
    {
        return kStatus_InvalidArgument;
    }
 
    /* Check that we're not busy.*/
    if (handle->state == kLPSPI_Busy)
    {
        return kStatus_LPSPI_Busy;
    }
 
    handle->state = kLPSPI_Busy;
 
    uint32_t instance = LPSPI_GetInstance(base);
    uint32_t rxAddr = LPSPI_GetRxRegisterAddress(base);
    uint32_t txAddr = LPSPI_GetTxRegisterAddress(base);
 
    uint32_t whichPcs = (transfer->configFlags & LPSPI_MASTER_PCS_MASK) >> LPSPI_MASTER_PCS_SHIFT;
 
    /*Because DMA is fast enough , so set the RX and TX watermarks to 0 .*/
    uint8_t txWatermark = 0;
    uint8_t rxWatermark = 0;
 
    /*Used for byte swap*/
    uint32_t dif = 0;
 
    uint8_t bytesLastWrite = 0;
 
    bool isThereExtraTxBytes = false;
 
    uint8_t dummyData = g_lpspiDummyData[instance];
 
    edma_transfer_config_t transferConfigRx;
    edma_transfer_config_t transferConfigTx;
 
    edma_tcd_t *softwareTCD_extraBytes = (edma_tcd_t *)((uint32_t)(&handle->lpspiSoftwareTCD[1]) & (~0x1FU));
    edma_tcd_t *softwareTCD_pcsContinuous = (edma_tcd_t *)((uint32_t)(&handle->lpspiSoftwareTCD[2]) & (~0x1FU));
 
    handle->txData = transfer->txData;
    handle->rxData = transfer->rxData;
    handle->txRemainingByteCount = transfer->dataSize;
    handle->rxRemainingByteCount = transfer->dataSize;
    handle->totalByteCount = transfer->dataSize;
 
    handle->writeRegRemainingTimes = (transfer->dataSize / bytesPerFrame) * ((bytesPerFrame + 3) / 4);
    handle->readRegRemainingTimes = handle->writeRegRemainingTimes;
 
    handle->txBuffIfNull =
        ((uint32_t)dummyData) | ((uint32_t)dummyData << 8) | ((uint32_t)dummyData << 16) | ((uint32_t)dummyData << 24);
 
    /*The TX and RX FIFO sizes are always the same*/
    handle->fifoSize = LPSPI_GetRxFifoSize(base);
 
    handle->isPcsContinuous = (bool)(transfer->configFlags & kLPSPI_MasterPcsContinuous);
    handle->isByteSwap = (bool)(transfer->configFlags & kLPSPI_MasterByteSwap);
 
    LPSPI_SetFifoWatermarks(base, txWatermark, rxWatermark);
 
    /*Transfers will stall when transmit FIFO is empty or receive FIFO is full. */
    LPSPI_Enable(base, false);
    base->CFGR1 &= (~LPSPI_CFGR1_NOSTALL_MASK);
    /* Check if using 3-wire mode and the txData is NULL, set the output pin to tristated. */
    temp = base->CFGR1;
    temp &= LPSPI_CFGR1_PINCFG_MASK;
    if ((temp == LPSPI_CFGR1_PINCFG(kLPSPI_SdiInSdiOut)) || (temp == LPSPI_CFGR1_PINCFG(kLPSPI_SdoInSdoOut)))
    {
        if (!handle->txData)
        {
            base->CFGR1 |= LPSPI_CFGR1_OUTCFG_MASK;
        }
        /* The 3-wire mode can't send and receive data at the same time. */
        if ((handle->txData) && (handle->rxData))
        {
            return kStatus_InvalidArgument;
        }
    }
 
    /*Flush FIFO , clear status , disable all the inerrupts.*/
    LPSPI_FlushFifo(base, true, true);
    LPSPI_ClearStatusFlags(base, kLPSPI_AllStatusFlag);
    LPSPI_DisableInterrupts(base, kLPSPI_AllInterruptEnable);
 
    /* For DMA transfer , we'd better not masked the transmit data and receive data in TCR since the transfer flow is
     * hard to controlled by software.
     */
    base->TCR = (base->TCR & ~(LPSPI_TCR_CONT_MASK | LPSPI_TCR_CONTC_MASK | LPSPI_TCR_BYSW_MASK | LPSPI_TCR_PCS_MASK)) |
                LPSPI_TCR_CONT(handle->isPcsContinuous) | LPSPI_TCR_CONTC(0U) | LPSPI_TCR_BYSW(handle->isByteSwap) |
                LPSPI_TCR_PCS(whichPcs);
 
    isThereExtraTxBytes = false;
    handle->isThereExtraRxBytes = false;
 
    /*Calculate the bytes for write/read the TX/RX register each time*/
    if (bytesPerFrame <= 4)
    {
        handle->bytesEachWrite = bytesPerFrame;
        handle->bytesEachRead = bytesPerFrame;
 
        handle->bytesLastRead = bytesPerFrame;
    }
    else
    {
        handle->bytesEachWrite = 4;
        handle->bytesEachRead = 4;
 
        handle->bytesLastRead = 4;
 
        if ((transfer->dataSize % 4) != 0)
        {
            bytesLastWrite = transfer->dataSize % 4;
            handle->bytesLastRead = bytesLastWrite;
 
            isThereExtraTxBytes = true;
 
            --handle->writeRegRemainingTimes;
 
            --handle->readRegRemainingTimes;
            handle->isThereExtraRxBytes = true;
        }
    }
 
    LPSPI_DisableDMA(base, kLPSPI_RxDmaEnable | kLPSPI_TxDmaEnable);
 
    EDMA_SetCallback(handle->edmaRxRegToRxDataHandle, EDMA_LpspiMasterCallback,
                     &s_lpspiMasterEdmaPrivateHandle[instance]);
 
    /*Rx*/
    EDMA_ResetChannel(handle->edmaRxRegToRxDataHandle->base, handle->edmaRxRegToRxDataHandle->channel);
 
    if (handle->rxData)
    {
        transferConfigRx.destAddr = (uint32_t) & (handle->rxData[0]);
        transferConfigRx.destOffset = 1;
    }
    else
    {
        transferConfigRx.destAddr = (uint32_t) & (handle->rxBuffIfNull);
        transferConfigRx.destOffset = 0;
    }
    transferConfigRx.destTransferSize = kEDMA_TransferSize1Bytes;
 
    dif = 0;
    switch (handle->bytesEachRead)
    {
        case (1U):
            transferConfigRx.srcTransferSize = kEDMA_TransferSize1Bytes;
            transferConfigRx.minorLoopBytes = 1;
            if (handle->isByteSwap)
            {
                dif = 3;
            }
            break;
 
        case (2U):
            transferConfigRx.srcTransferSize = kEDMA_TransferSize2Bytes;
            transferConfigRx.minorLoopBytes = 2;
            if (handle->isByteSwap)
            {
                dif = 2;
            }
            break;
 
        case (4U):
            transferConfigRx.srcTransferSize = kEDMA_TransferSize4Bytes;
            transferConfigRx.minorLoopBytes = 4;
            break;
 
        default:
            transferConfigRx.srcTransferSize = kEDMA_TransferSize1Bytes;
            transferConfigRx.minorLoopBytes = 1;
            assert(false);
            break;
    }
 
    transferConfigRx.srcAddr = (uint32_t)rxAddr + dif;
    transferConfigRx.srcOffset = 0;
 
    transferConfigRx.majorLoopCounts = handle->readRegRemainingTimes;
 
    /* Store the initially configured eDMA minor byte transfer count into the LPSPI handle */
    handle->nbytes = transferConfigRx.minorLoopBytes;
 
    EDMA_SetTransferConfig(handle->edmaRxRegToRxDataHandle->base, handle->edmaRxRegToRxDataHandle->channel,
                           &transferConfigRx, NULL);
    EDMA_EnableChannelInterrupts(handle->edmaRxRegToRxDataHandle->base, handle->edmaRxRegToRxDataHandle->channel,
                                 kEDMA_MajorInterruptEnable);
 
    /*Tx*/
    EDMA_ResetChannel(handle->edmaTxDataToTxRegHandle->base, handle->edmaTxDataToTxRegHandle->channel);
 
    if (isThereExtraTxBytes)
    {
        if (handle->txData)
        {
            transferConfigTx.srcAddr = (uint32_t) & (transfer->txData[transfer->dataSize - bytesLastWrite]);
            transferConfigTx.srcOffset = 1;
        }
        else
        {
            transferConfigTx.srcAddr = (uint32_t)(&handle->txBuffIfNull);
            transferConfigTx.srcOffset = 0;
        }
 
        transferConfigTx.destOffset = 0;
 
        transferConfigTx.srcTransferSize = kEDMA_TransferSize1Bytes;
 
        dif = 0;
        switch (bytesLastWrite)
        {
            case (1U):
                transferConfigTx.destTransferSize = kEDMA_TransferSize1Bytes;
                transferConfigTx.minorLoopBytes = 1;
                if (handle->isByteSwap)
                {
                    dif = 3;
                }
                break;
 
            case (2U):
                transferConfigTx.destTransferSize = kEDMA_TransferSize2Bytes;
                transferConfigTx.minorLoopBytes = 2;
                if (handle->isByteSwap)
                {
                    dif = 2;
                }
                break;
 
            default:
                transferConfigTx.destTransferSize = kEDMA_TransferSize1Bytes;
                transferConfigTx.minorLoopBytes = 1;
                assert(false);
                break;
        }
 
        transferConfigTx.destAddr = (uint32_t)txAddr + dif;
        transferConfigTx.majorLoopCounts = 1;
 
        EDMA_TcdReset(softwareTCD_extraBytes);
 
        if (handle->isPcsContinuous)
        {
            EDMA_TcdSetTransferConfig(softwareTCD_extraBytes, &transferConfigTx, softwareTCD_pcsContinuous);
        }
        else
        {
            EDMA_TcdSetTransferConfig(softwareTCD_extraBytes, &transferConfigTx, NULL);
        }
    }
 
    if (handle->isPcsContinuous)
    {
        handle->transmitCommand = base->TCR & ~(LPSPI_TCR_CONTC_MASK | LPSPI_TCR_CONT_MASK);
 
        transferConfigTx.srcAddr = (uint32_t) & (handle->transmitCommand);
        transferConfigTx.srcOffset = 0;
 
        transferConfigTx.destAddr = (uint32_t) & (base->TCR);
        transferConfigTx.destOffset = 0;
 
        transferConfigTx.srcTransferSize = kEDMA_TransferSize4Bytes;
        transferConfigTx.destTransferSize = kEDMA_TransferSize4Bytes;
        transferConfigTx.minorLoopBytes = 4;
        transferConfigTx.majorLoopCounts = 1;
 
        EDMA_TcdReset(softwareTCD_pcsContinuous);
        EDMA_TcdSetTransferConfig(softwareTCD_pcsContinuous, &transferConfigTx, NULL);
    }
 
    if (handle->txData)
    {
        transferConfigTx.srcAddr = (uint32_t)(handle->txData);
        transferConfigTx.srcOffset = 1;
    }
    else
    {
        transferConfigTx.srcAddr = (uint32_t)(&handle->txBuffIfNull);
        transferConfigTx.srcOffset = 0;
    }
 
    transferConfigTx.destOffset = 0;
 
    transferConfigTx.srcTransferSize = kEDMA_TransferSize1Bytes;
 
    dif = 0;
    switch (handle->bytesEachRead)
    {
        case (1U):
            transferConfigTx.destTransferSize = kEDMA_TransferSize1Bytes;
            transferConfigTx.minorLoopBytes = 1;
            if (handle->isByteSwap)
            {
                dif = 3;
            }
            break;
 
        case (2U):
            transferConfigTx.destTransferSize = kEDMA_TransferSize2Bytes;
            transferConfigTx.minorLoopBytes = 2;
 
            if (handle->isByteSwap)
            {
                dif = 2;
            }
            break;
 
        case (4U):
            transferConfigTx.destTransferSize = kEDMA_TransferSize4Bytes;
            transferConfigTx.minorLoopBytes = 4;
            break;
 
        default:
            transferConfigTx.destTransferSize = kEDMA_TransferSize1Bytes;
            transferConfigTx.minorLoopBytes = 1;
            assert(false);
            break;
    }
 
    transferConfigTx.destAddr = (uint32_t)txAddr + dif;
 
    transferConfigTx.majorLoopCounts = handle->writeRegRemainingTimes;
 
    if (isThereExtraTxBytes)
    {
        EDMA_SetTransferConfig(handle->edmaTxDataToTxRegHandle->base, handle->edmaTxDataToTxRegHandle->channel,
                               &transferConfigTx, softwareTCD_extraBytes);
    }
    else if (handle->isPcsContinuous)
    {
        EDMA_SetTransferConfig(handle->edmaTxDataToTxRegHandle->base, handle->edmaTxDataToTxRegHandle->channel,
                               &transferConfigTx, softwareTCD_pcsContinuous);
    }
    else
    {
        EDMA_SetTransferConfig(handle->edmaTxDataToTxRegHandle->base, handle->edmaTxDataToTxRegHandle->channel,
                               &transferConfigTx, NULL);
    }
 
    EDMA_StartTransfer(handle->edmaTxDataToTxRegHandle);
    EDMA_StartTransfer(handle->edmaRxRegToRxDataHandle);
 
    LPSPI_EnableDMA(base, kLPSPI_RxDmaEnable | kLPSPI_TxDmaEnable);
    LPSPI_Enable(base, true);
 
    return kStatus_Success;
}

Here is the call graph for this function:

LPSPI_MasterTransferGetCountEDMA()

status_t LPSPI_MasterTransferGetCountEDMA	(	LPSPI_Type *	base,
		lpspi_master_edma_handle_t *	handle,
		size_t *	count
	)

Gets the master eDMA transfer remaining bytes.

This function gets the master eDMA transfer remaining bytes.

Parameters

base	LPSPI peripheral base address.
handle	pointer to lpspi_master_edma_handle_t structure which stores the transfer state.
count	Number of bytes transferred so far by the EDMA transaction.

Returns

status of status_t.

brief Gets the master eDMA transfer remaining bytes.

This function gets the master eDMA transfer remaining bytes.

param base LPSPI peripheral base address. param handle pointer to lpspi_master_edma_handle_t structure which stores the transfer state. param count Number of bytes transferred so far by the EDMA transaction. return status of status_t.

Definition at line 653 of file fsl_lpspi_edma.c.

{
    assert(handle);
 
    if (!count)
    {
        return kStatus_InvalidArgument;
    }
 
    /* Catch when there is not an active transfer. */
    if (handle->state != kLPSPI_Busy)
    {
        *count = 0;
        return kStatus_NoTransferInProgress;
    }
 
    size_t remainingByte;
 
    remainingByte =
        (uint32_t)handle->nbytes * EDMA_GetRemainingMajorLoopCount(handle->edmaRxRegToRxDataHandle->base,
                                                                   handle->edmaRxRegToRxDataHandle->channel);
 
    *count = handle->totalByteCount - remainingByte;
 
    return kStatus_Success;
}

Here is the call graph for this function:

LPSPI_SlaveTransferAbortEDMA()

void LPSPI_SlaveTransferAbortEDMA	(	LPSPI_Type *	base,
		lpspi_slave_edma_handle_t *	handle
	)

LPSPI slave aborts a transfer which is using eDMA.

This function aborts a transfer which is using eDMA.

Parameters

base	LPSPI peripheral base address.
handle	pointer to lpspi_slave_edma_handle_t structure which stores the transfer state.

brief LPSPI slave aborts a transfer which is using eDMA.

This function aborts a transfer which is using eDMA.

param base LPSPI peripheral base address. param handle pointer to lpspi_slave_edma_handle_t structure which stores the transfer state.

Definition at line 1123 of file fsl_lpspi_edma.c.

{
    assert(handle);
 
    LPSPI_DisableDMA(base, kLPSPI_RxDmaEnable | kLPSPI_TxDmaEnable);
 
    EDMA_AbortTransfer(handle->edmaRxRegToRxDataHandle);
    EDMA_AbortTransfer(handle->edmaTxDataToTxRegHandle);
 
    handle->state = kLPSPI_Idle;
}

Here is the call graph for this function:

LPSPI_SlaveTransferCreateHandleEDMA()

void LPSPI_SlaveTransferCreateHandleEDMA	(	LPSPI_Type *	base,
		lpspi_slave_edma_handle_t *	handle,
		lpspi_slave_edma_transfer_callback_t	callback,
		void *	userData,
		edma_handle_t *	edmaRxRegToRxDataHandle,
		edma_handle_t *	edmaTxDataToTxRegHandle
	)

Initializes the LPSPI slave eDMA handle.

This function initializes the LPSPI eDMA handle which can be used for other LPSPI transactional APIs. Usually, for a specified LPSPI instance, call this API once to get the initialized handle.

Note that LPSPI eDMA has a separated (Rx and Tx as two sources) or shared (Rx and Tx as the same source) DMA request source.

(1) For a separated DMA request source, enable and set the Rx DMAMUX source for edmaRxRegToRxDataHandle and Tx DMAMUX source for edmaTxDataToTxRegHandle. (2) For a shared DMA request source, enable and set the Rx/Rx DMAMUX source for edmaRxRegToRxDataHandle .

Parameters

base	LPSPI peripheral base address.
handle	LPSPI handle pointer to lpspi_slave_edma_handle_t.
callback	LPSPI callback.
userData	callback function parameter.
edmaRxRegToRxDataHandle	edmaRxRegToRxDataHandle pointer to edma_handle_t.
edmaTxDataToTxRegHandle	edmaTxDataToTxRegHandle pointer to edma_handle_t.

brief Initializes the LPSPI slave eDMA handle.

This function initializes the LPSPI eDMA handle which can be used for other LPSPI transactional APIs. Usually, for a specified LPSPI instance, call this API once to get the initialized handle.

Note that LPSPI eDMA has a separated (Rx and Tx as two sources) or shared (Rx and Tx as the same source) DMA request source.

(1) For a separated DMA request source, enable and set the Rx DMAMUX source for edmaRxRegToRxDataHandle and Tx DMAMUX source for edmaTxDataToTxRegHandle. (2) For a shared DMA request source, enable and set the Rx/Rx DMAMUX source for edmaRxRegToRxDataHandle .

param base LPSPI peripheral base address. param handle LPSPI handle pointer to lpspi_slave_edma_handle_t. param callback LPSPI callback. param userData callback function parameter. param edmaRxRegToRxDataHandle edmaRxRegToRxDataHandle pointer to edma_handle_t. param edmaTxDataToTxRegHandle edmaTxDataToTxRegHandle pointer to edma_handle_t.

Definition at line 700 of file fsl_lpspi_edma.c.

{
    assert(handle);
    assert(edmaRxRegToRxDataHandle);
    assert(edmaTxDataToTxRegHandle);
 
    /* Zero the handle. */
    memset(handle, 0, sizeof(*handle));
 
    uint32_t instance = LPSPI_GetInstance(base);
 
    s_lpspiSlaveEdmaPrivateHandle[instance].base = base;
    s_lpspiSlaveEdmaPrivateHandle[instance].handle = handle;
 
    handle->callback = callback;
    handle->userData = userData;
 
    handle->edmaRxRegToRxDataHandle = edmaRxRegToRxDataHandle;
    handle->edmaTxDataToTxRegHandle = edmaTxDataToTxRegHandle;
}

Here is the call graph for this function:

LPSPI_SlaveTransferEDMA()

status_t LPSPI_SlaveTransferEDMA	(	LPSPI_Type *	base,
		lpspi_slave_edma_handle_t *	handle,
		lpspi_transfer_t *	transfer
	)

LPSPI slave transfers data using eDMA.

This function transfers data using eDMA. This is a non-blocking function, which return right away. When all data is transferred, the callback function is called.

Note: The transfer data size should be an integer multiple of bytesPerFrame if bytesPerFrame is less than or equal to 4. For bytesPerFrame greater than 4: The transfer data size should be equal to bytesPerFrame if the bytesPerFrame is not an integer multiple of 4. Otherwise, the transfer data size can be an integer multiple of bytesPerFrame.

Parameters

base	LPSPI peripheral base address.
handle	pointer to lpspi_slave_edma_handle_t structure which stores the transfer state.
transfer	pointer to lpspi_transfer_t structure.

Returns

status of status_t.

brief LPSPI slave transfers data using eDMA.

This function transfers data using eDMA. This is a non-blocking function, which return right away. When all data is transferred, the callback function is called.

Note: The transfer data size should be an integer multiple of bytesPerFrame if bytesPerFrame is less than or equal to 4. For bytesPerFrame greater than 4: The transfer data size should be equal to bytesPerFrame if the bytesPerFrame is not an integer multiple of 4. Otherwise, the transfer data size can be an integer multiple of bytesPerFrame.

param base LPSPI peripheral base address. param handle pointer to lpspi_slave_edma_handle_t structure which stores the transfer state. param transfer pointer to lpspi_transfer_t structure. return status of status_t.

Definition at line 743 of file fsl_lpspi_edma.c.

{
    assert(handle);
    assert(transfer);
 
    uint32_t bitsPerFrame = ((base->TCR & LPSPI_TCR_FRAMESZ_MASK) >> LPSPI_TCR_FRAMESZ_SHIFT) + 1;
    uint32_t bytesPerFrame = (bitsPerFrame + 7) / 8;
    uint32_t temp = 0U;
 
    uint8_t dummyData = g_lpspiDummyData[LPSPI_GetInstance(base)];
 
    if (!LPSPI_CheckTransferArgument(transfer, bitsPerFrame, bytesPerFrame))
    {
        return kStatus_InvalidArgument;
    }
 
    /*And since the dma transfer can not support 3 bytes .*/
    if ((bytesPerFrame % 4U) == 3)
    {
        return kStatus_InvalidArgument;
    }
 
    /* Check that we're not busy.*/
    if (handle->state == kLPSPI_Busy)
    {
        return kStatus_LPSPI_Busy;
    }
 
    handle->state = kLPSPI_Busy;
 
    uint32_t rxAddr = LPSPI_GetRxRegisterAddress(base);
    uint32_t txAddr = LPSPI_GetTxRegisterAddress(base);
 
    edma_tcd_t *softwareTCD_extraBytes = (edma_tcd_t *)((uint32_t)(&handle->lpspiSoftwareTCD[1]) & (~0x1FU));
 
    uint32_t whichPcs = (transfer->configFlags & LPSPI_MASTER_PCS_MASK) >> LPSPI_MASTER_PCS_SHIFT;
 
    /*Because DMA is fast enough , so set the RX and TX watermarks to 0 .*/
    uint8_t txWatermark = 0;
    uint8_t rxWatermark = 0;
 
    /*Used for byte swap*/
    uint32_t dif = 0;
 
    uint8_t bytesLastWrite = 0;
 
    uint32_t instance = LPSPI_GetInstance(base);
 
    edma_transfer_config_t transferConfigRx;
    edma_transfer_config_t transferConfigTx;
 
    bool isThereExtraTxBytes = false;
 
    handle->txData = transfer->txData;
    handle->rxData = transfer->rxData;
    handle->txRemainingByteCount = transfer->dataSize;
    handle->rxRemainingByteCount = transfer->dataSize;
    handle->totalByteCount = transfer->dataSize;
 
    handle->writeRegRemainingTimes = (transfer->dataSize / bytesPerFrame) * ((bytesPerFrame + 3) / 4);
    handle->readRegRemainingTimes = handle->writeRegRemainingTimes;
 
    handle->txBuffIfNull =
        ((uint32_t)dummyData) | ((uint32_t)dummyData << 8) | ((uint32_t)dummyData << 16) | ((uint32_t)dummyData << 24);
 
    /*The TX and RX FIFO sizes are always the same*/
    handle->fifoSize = LPSPI_GetRxFifoSize(base);
 
    handle->isByteSwap = (bool)(transfer->configFlags & kLPSPI_MasterByteSwap);
 
    LPSPI_SetFifoWatermarks(base, txWatermark, rxWatermark);
 
    /*Transfers will stall when transmit FIFO is empty or receive FIFO is full. */
    LPSPI_Enable(base, false);
    base->CFGR1 &= (~LPSPI_CFGR1_NOSTALL_MASK);
    /* Check if using 3-wire mode and the txData is NULL, set the output pin to tristated. */
    temp = base->CFGR1;
    temp &= LPSPI_CFGR1_PINCFG_MASK;
    if ((temp == LPSPI_CFGR1_PINCFG(kLPSPI_SdiInSdiOut)) || (temp == LPSPI_CFGR1_PINCFG(kLPSPI_SdoInSdoOut)))
    {
        if (!handle->txData)
        {
            base->CFGR1 |= LPSPI_CFGR1_OUTCFG_MASK;
        }
        /* The 3-wire mode can't send and receive data at the same time. */
        if ((handle->txData) && (handle->rxData))
        {
            return kStatus_InvalidArgument;
        }
    }
 
    /*Flush FIFO , clear status , disable all the inerrupts.*/
    LPSPI_FlushFifo(base, true, true);
    LPSPI_ClearStatusFlags(base, kLPSPI_AllStatusFlag);
    LPSPI_DisableInterrupts(base, kLPSPI_AllInterruptEnable);
 
    /* For DMA transfer , we'd better not masked the transmit data and receive data in TCR since the transfer flow is
     * hard to controlled by software.
     */
    base->TCR = (base->TCR & ~(LPSPI_TCR_CONT_MASK | LPSPI_TCR_CONTC_MASK | LPSPI_TCR_BYSW_MASK)) |
                LPSPI_TCR_CONTC(0U) | LPSPI_TCR_BYSW(handle->isByteSwap) | LPSPI_TCR_PCS(whichPcs);
 
    isThereExtraTxBytes = false;
    handle->isThereExtraRxBytes = false;
 
    /*Calculate the bytes for write/read the TX/RX register each time*/
    if (bytesPerFrame <= 4)
    {
        handle->bytesEachWrite = bytesPerFrame;
        handle->bytesEachRead = bytesPerFrame;
 
        handle->bytesLastRead = bytesPerFrame;
    }
    else
    {
        handle->bytesEachWrite = 4;
        handle->bytesEachRead = 4;
 
        handle->bytesLastRead = 4;
 
        if ((transfer->dataSize % 4) != 0)
        {
            bytesLastWrite = transfer->dataSize % 4;
            handle->bytesLastRead = bytesLastWrite;
 
            isThereExtraTxBytes = true;
            --handle->writeRegRemainingTimes;
 
            handle->isThereExtraRxBytes = true;
            --handle->readRegRemainingTimes;
        }
    }
 
    LPSPI_DisableDMA(base, kLPSPI_RxDmaEnable | kLPSPI_TxDmaEnable);
 
    EDMA_SetCallback(handle->edmaRxRegToRxDataHandle, EDMA_LpspiSlaveCallback,
                     &s_lpspiSlaveEdmaPrivateHandle[instance]);
 
    /*Rx*/
    if (handle->readRegRemainingTimes > 0)
    {
        EDMA_ResetChannel(handle->edmaRxRegToRxDataHandle->base, handle->edmaRxRegToRxDataHandle->channel);
 
        if (handle->rxData)
        {
            transferConfigRx.destAddr = (uint32_t) & (handle->rxData[0]);
            transferConfigRx.destOffset = 1;
        }
        else
        {
            transferConfigRx.destAddr = (uint32_t) & (handle->rxBuffIfNull);
            transferConfigRx.destOffset = 0;
        }
        transferConfigRx.destTransferSize = kEDMA_TransferSize1Bytes;
 
        dif = 0;
        switch (handle->bytesEachRead)
        {
            case (1U):
                transferConfigRx.srcTransferSize = kEDMA_TransferSize1Bytes;
                transferConfigRx.minorLoopBytes = 1;
                if (handle->isByteSwap)
                {
                    dif = 3;
                }
                break;
 
            case (2U):
                transferConfigRx.srcTransferSize = kEDMA_TransferSize2Bytes;
                transferConfigRx.minorLoopBytes = 2;
                if (handle->isByteSwap)
                {
                    dif = 2;
                }
                break;
 
            case (4U):
                transferConfigRx.srcTransferSize = kEDMA_TransferSize4Bytes;
                transferConfigRx.minorLoopBytes = 4;
                break;
 
            default:
                transferConfigRx.srcTransferSize = kEDMA_TransferSize1Bytes;
                transferConfigRx.minorLoopBytes = 1;
                assert(false);
                break;
        }
 
        transferConfigRx.srcAddr = (uint32_t)rxAddr + dif;
        transferConfigRx.srcOffset = 0;
 
        transferConfigRx.majorLoopCounts = handle->readRegRemainingTimes;
 
        /* Store the initially configured eDMA minor byte transfer count into the DSPI handle */
        handle->nbytes = transferConfigRx.minorLoopBytes;
 
        EDMA_SetTransferConfig(handle->edmaRxRegToRxDataHandle->base, handle->edmaRxRegToRxDataHandle->channel,
                               &transferConfigRx, NULL);
        EDMA_EnableChannelInterrupts(handle->edmaRxRegToRxDataHandle->base, handle->edmaRxRegToRxDataHandle->channel,
                                     kEDMA_MajorInterruptEnable);
    }
 
    /*Tx*/
    EDMA_ResetChannel(handle->edmaTxDataToTxRegHandle->base, handle->edmaTxDataToTxRegHandle->channel);
 
    if (isThereExtraTxBytes)
    {
        if (handle->txData)
        {
            transferConfigTx.srcAddr = (uint32_t) & (transfer->txData[transfer->dataSize - bytesLastWrite]);
            transferConfigTx.srcOffset = 1;
        }
        else
        {
            transferConfigTx.srcAddr = (uint32_t)(&handle->txBuffIfNull);
            transferConfigTx.srcOffset = 0;
        }
 
        transferConfigTx.destOffset = 0;
 
        transferConfigTx.srcTransferSize = kEDMA_TransferSize1Bytes;
 
        dif = 0;
        switch (bytesLastWrite)
        {
            case (1U):
                transferConfigTx.destTransferSize = kEDMA_TransferSize1Bytes;
                transferConfigTx.minorLoopBytes = 1;
                if (handle->isByteSwap)
                {
                    dif = 3;
                }
                break;
 
            case (2U):
                transferConfigTx.destTransferSize = kEDMA_TransferSize2Bytes;
                transferConfigTx.minorLoopBytes = 2;
                if (handle->isByteSwap)
                {
                    dif = 2;
                }
                break;
 
            default:
                transferConfigTx.destTransferSize = kEDMA_TransferSize1Bytes;
                transferConfigTx.minorLoopBytes = 1;
                assert(false);
                break;
        }
 
        transferConfigTx.destAddr = (uint32_t)txAddr + dif;
        transferConfigTx.majorLoopCounts = 1;
 
        EDMA_TcdReset(softwareTCD_extraBytes);
 
        EDMA_TcdSetTransferConfig(softwareTCD_extraBytes, &transferConfigTx, NULL);
    }
 
    if (handle->txData)
    {
        transferConfigTx.srcAddr = (uint32_t)(handle->txData);
        transferConfigTx.srcOffset = 1;
    }
    else
    {
        transferConfigTx.srcAddr = (uint32_t)(&handle->txBuffIfNull);
        transferConfigTx.srcOffset = 0;
    }
 
    transferConfigTx.destOffset = 0;
 
    transferConfigTx.srcTransferSize = kEDMA_TransferSize1Bytes;
 
    dif = 0;
    switch (handle->bytesEachRead)
    {
        case (1U):
            transferConfigTx.destTransferSize = kEDMA_TransferSize1Bytes;
            transferConfigTx.minorLoopBytes = 1;
            if (handle->isByteSwap)
            {
                dif = 3;
            }
            break;
 
        case (2U):
            transferConfigTx.destTransferSize = kEDMA_TransferSize2Bytes;
            transferConfigTx.minorLoopBytes = 2;
 
            if (handle->isByteSwap)
            {
                dif = 2;
            }
            break;
 
        case (4U):
            transferConfigTx.destTransferSize = kEDMA_TransferSize4Bytes;
            transferConfigTx.minorLoopBytes = 4;
            break;
 
        default:
            transferConfigTx.destTransferSize = kEDMA_TransferSize1Bytes;
            transferConfigTx.minorLoopBytes = 1;
            assert(false);
            break;
    }
 
    transferConfigTx.destAddr = (uint32_t)txAddr + dif;
 
    transferConfigTx.majorLoopCounts = handle->writeRegRemainingTimes;
 
    if (isThereExtraTxBytes)
    {
        EDMA_SetTransferConfig(handle->edmaTxDataToTxRegHandle->base, handle->edmaTxDataToTxRegHandle->channel,
                               &transferConfigTx, softwareTCD_extraBytes);
    }
    else
    {
        EDMA_SetTransferConfig(handle->edmaTxDataToTxRegHandle->base, handle->edmaTxDataToTxRegHandle->channel,
                               &transferConfigTx, NULL);
    }
 
    EDMA_StartTransfer(handle->edmaTxDataToTxRegHandle);
    EDMA_StartTransfer(handle->edmaRxRegToRxDataHandle);
 
    LPSPI_EnableDMA(base, kLPSPI_RxDmaEnable | kLPSPI_TxDmaEnable);
    LPSPI_Enable(base, true);
 
    return kStatus_Success;
}

Here is the call graph for this function:

LPSPI_SlaveTransferGetCountEDMA()

status_t LPSPI_SlaveTransferGetCountEDMA	(	LPSPI_Type *	base,
		lpspi_slave_edma_handle_t *	handle,
		size_t *	count
	)

Gets the slave eDMA transfer remaining bytes.

This function gets the slave eDMA transfer remaining bytes.

Parameters

base	LPSPI peripheral base address.
handle	pointer to lpspi_slave_edma_handle_t structure which stores the transfer state.
count	Number of bytes transferred so far by the eDMA transaction.

Returns

status of status_t.

brief Gets the slave eDMA transfer remaining bytes.

This function gets the slave eDMA transfer remaining bytes.

param base LPSPI peripheral base address. param handle pointer to lpspi_slave_edma_handle_t structure which stores the transfer state. param count Number of bytes transferred so far by the eDMA transaction. return status of status_t.

Definition at line 1145 of file fsl_lpspi_edma.c.

{
    assert(handle);
 
    if (!count)
    {
        return kStatus_InvalidArgument;
    }
 
    /* Catch when there is not an active transfer. */
    if (handle->state != kLPSPI_Busy)
    {
        *count = 0;
        return kStatus_NoTransferInProgress;
    }
 
    size_t remainingByte;
 
    remainingByte =
        (uint32_t)handle->nbytes * EDMA_GetRemainingMajorLoopCount(handle->edmaRxRegToRxDataHandle->base,
                                                                   handle->edmaRxRegToRxDataHandle->channel);
 
    *count = handle->totalByteCount - remainingByte;
 
    return kStatus_Success;
}

Here is the call graph for this function:

Variable Documentation

bytesEachRead [1/2]

volatile uint8_t _lpspi_master_edma_handle::bytesEachRead

Bytes for each read RDR.

Definition at line 75 of file fsl_lpspi_edma.h.

Referenced by LPSPI_MasterTransferEDMA().

bytesEachRead [2/2]

volatile uint8_t _lpspi_slave_edma_handle::bytesEachRead

Bytes for each read RDR.

Definition at line 118 of file fsl_lpspi_edma.h.

Referenced by LPSPI_SlaveTransferEDMA().

bytesEachWrite [1/2]

volatile uint8_t _lpspi_master_edma_handle::bytesEachWrite

Bytes for each write TDR.

Definition at line 74 of file fsl_lpspi_edma.h.

Referenced by LPSPI_MasterTransferEDMA().

bytesEachWrite [2/2]

volatile uint8_t _lpspi_slave_edma_handle::bytesEachWrite

Bytes for each write TDR.

Definition at line 117 of file fsl_lpspi_edma.h.

Referenced by LPSPI_SlaveTransferEDMA().

bytesLastRead [1/2]

volatile uint8_t _lpspi_master_edma_handle::bytesLastRead

Bytes for last read RDR.

Definition at line 77 of file fsl_lpspi_edma.h.

Referenced by LPSPI_MasterTransferEDMA().

bytesLastRead [2/2]

volatile uint8_t _lpspi_slave_edma_handle::bytesLastRead

Bytes for last read RDR.

Definition at line 120 of file fsl_lpspi_edma.h.

Referenced by LPSPI_SlaveTransferEDMA().

callback [1/2]

lpspi_master_edma_transfer_callback_t _lpspi_master_edma_handle::callback

Completion callback.

Definition at line 99 of file fsl_lpspi_edma.h.

Referenced by LPSPI_MasterTransferCreateHandleEDMA().

callback [2/2]

lpspi_slave_edma_transfer_callback_t _lpspi_slave_edma_handle::callback

Completion callback.

Definition at line 142 of file fsl_lpspi_edma.h.

Referenced by LPSPI_SlaveTransferCreateHandleEDMA().

edmaRxRegToRxDataHandle [1/2]

edma_handle_t* _lpspi_master_edma_handle::edmaRxRegToRxDataHandle

edma_handle_t handle point used for RxReg to RxData buff

Definition at line 102 of file fsl_lpspi_edma.h.

Referenced by LPSPI_MasterTransferAbortEDMA(), LPSPI_MasterTransferCreateHandleEDMA(), LPSPI_MasterTransferEDMA(), and LPSPI_MasterTransferGetCountEDMA().

edmaRxRegToRxDataHandle [2/2]

edma_handle_t* _lpspi_slave_edma_handle::edmaRxRegToRxDataHandle

edma_handle_t handle point used for RxReg to RxData buff

Definition at line 145 of file fsl_lpspi_edma.h.

Referenced by LPSPI_SlaveTransferAbortEDMA(), LPSPI_SlaveTransferCreateHandleEDMA(), LPSPI_SlaveTransferEDMA(), and LPSPI_SlaveTransferGetCountEDMA().

edmaTxDataToTxRegHandle [1/2]

edma_handle_t* _lpspi_master_edma_handle::edmaTxDataToTxRegHandle

edma_handle_t handle point used for TxData to TxReg buff

Definition at line 103 of file fsl_lpspi_edma.h.

Referenced by LPSPI_MasterTransferAbortEDMA(), LPSPI_MasterTransferCreateHandleEDMA(), and LPSPI_MasterTransferEDMA().

edmaTxDataToTxRegHandle [2/2]

edma_handle_t* _lpspi_slave_edma_handle::edmaTxDataToTxRegHandle

edma_handle_t handle point used for TxData to TxReg

Definition at line 146 of file fsl_lpspi_edma.h.

Referenced by LPSPI_SlaveTransferAbortEDMA(), LPSPI_SlaveTransferCreateHandleEDMA(), and LPSPI_SlaveTransferEDMA().

errorCount

uint32_t _lpspi_slave_edma_handle::errorCount

Error count for slave transfer.

Definition at line 140 of file fsl_lpspi_edma.h.

fifoSize [1/2]

volatile uint8_t _lpspi_master_edma_handle::fifoSize

FIFO dataSize.

Definition at line 70 of file fsl_lpspi_edma.h.

Referenced by LPSPI_MasterTransferEDMA().

fifoSize [2/2]

volatile uint8_t _lpspi_slave_edma_handle::fifoSize

FIFO dataSize.

Definition at line 113 of file fsl_lpspi_edma.h.

Referenced by LPSPI_SlaveTransferEDMA().

isByteSwap [1/2]

volatile bool _lpspi_master_edma_handle::isByteSwap

A flag that whether should byte swap.

Definition at line 68 of file fsl_lpspi_edma.h.

Referenced by LPSPI_MasterTransferEDMA().

isByteSwap [2/2]

volatile bool _lpspi_slave_edma_handle::isByteSwap

A flag that whether should byte swap.

Definition at line 111 of file fsl_lpspi_edma.h.

Referenced by LPSPI_SlaveTransferEDMA().

isPcsContinuous

volatile bool _lpspi_master_edma_handle::isPcsContinuous

Is PCS continuous in transfer.

Definition at line 66 of file fsl_lpspi_edma.h.

Referenced by LPSPI_MasterTransferEDMA().

isThereExtraRxBytes [1/2]

volatile uint8_t _lpspi_master_edma_handle::isThereExtraRxBytes

Is there extra RX byte.

Definition at line 78 of file fsl_lpspi_edma.h.

Referenced by LPSPI_MasterTransferEDMA().

isThereExtraRxBytes [2/2]

volatile uint8_t _lpspi_slave_edma_handle::isThereExtraRxBytes

Is there extra RX byte.

Definition at line 121 of file fsl_lpspi_edma.h.

Referenced by LPSPI_SlaveTransferEDMA().

lpspiSoftwareTCD [1/2]

edma_tcd_t _lpspi_slave_edma_handle::lpspiSoftwareTCD[2]

SoftwareTCD, internal used

Definition at line 148 of file fsl_lpspi_edma.h.

Referenced by LPSPI_SlaveTransferEDMA().

lpspiSoftwareTCD [2/2]

edma_tcd_t _lpspi_master_edma_handle::lpspiSoftwareTCD[3]

SoftwareTCD, internal used

Definition at line 105 of file fsl_lpspi_edma.h.

Referenced by LPSPI_MasterTransferEDMA().

nbytes [1/2]

uint8_t _lpspi_master_edma_handle::nbytes

eDMA minor byte transfer count initially configured.

Definition at line 97 of file fsl_lpspi_edma.h.

Referenced by LPSPI_MasterTransferEDMA(), and LPSPI_MasterTransferGetCountEDMA().

nbytes [2/2]

uint8_t _lpspi_slave_edma_handle::nbytes

eDMA minor byte transfer count initially configured.

Definition at line 123 of file fsl_lpspi_edma.h.

Referenced by LPSPI_SlaveTransferEDMA(), and LPSPI_SlaveTransferGetCountEDMA().

readRegRemainingTimes [1/2]

volatile uint32_t _lpspi_master_edma_handle::readRegRemainingTimes

Read RDR register remaining times.

Definition at line 86 of file fsl_lpspi_edma.h.

Referenced by LPSPI_MasterTransferEDMA().

readRegRemainingTimes [2/2]

volatile uint32_t _lpspi_slave_edma_handle::readRegRemainingTimes

Read RDR register remaining times.

Definition at line 131 of file fsl_lpspi_edma.h.

Referenced by LPSPI_SlaveTransferEDMA().

rxBuffIfNull [1/2]

uint32_t _lpspi_master_edma_handle::rxBuffIfNull

Used if there is not rxData for DMA purpose.

Definition at line 91 of file fsl_lpspi_edma.h.

Referenced by LPSPI_MasterTransferEDMA().

rxBuffIfNull [2/2]

uint32_t _lpspi_slave_edma_handle::rxBuffIfNull

Used if there is not rxData for DMA purpose.

Definition at line 136 of file fsl_lpspi_edma.h.

Referenced by LPSPI_SlaveTransferEDMA().

rxData [1/2]

uint8_t* volatile _lpspi_master_edma_handle::rxData

Receive buffer.

Definition at line 81 of file fsl_lpspi_edma.h.

Referenced by LPSPI_MasterTransferEDMA().

rxData [2/2]

uint8_t* volatile _lpspi_slave_edma_handle::rxData

Receive buffer.

Definition at line 126 of file fsl_lpspi_edma.h.

Referenced by LPSPI_SlaveTransferEDMA().

rxRemainingByteCount [1/2]

volatile size_t _lpspi_master_edma_handle::rxRemainingByteCount

Number of bytes remaining to receive.

Definition at line 83 of file fsl_lpspi_edma.h.

Referenced by LPSPI_MasterTransferEDMA().

rxRemainingByteCount [2/2]

volatile size_t _lpspi_slave_edma_handle::rxRemainingByteCount

Number of bytes remaining to receive.

Definition at line 128 of file fsl_lpspi_edma.h.

Referenced by LPSPI_SlaveTransferEDMA().

rxWatermark [1/2]

volatile uint8_t _lpspi_master_edma_handle::rxWatermark

Rx watermark.

Definition at line 72 of file fsl_lpspi_edma.h.

rxWatermark [2/2]

volatile uint8_t _lpspi_slave_edma_handle::rxWatermark

Rx watermark.

Definition at line 115 of file fsl_lpspi_edma.h.

state [1/2]

volatile uint8_t _lpspi_master_edma_handle::state

LPSPI transfer state , _lpspi_transfer_state.

Definition at line 95 of file fsl_lpspi_edma.h.

Referenced by LPSPI_MasterTransferAbortEDMA(), LPSPI_MasterTransferEDMA(), and LPSPI_MasterTransferGetCountEDMA().

state [2/2]

volatile uint8_t _lpspi_slave_edma_handle::state

LPSPI transfer state.

Definition at line 138 of file fsl_lpspi_edma.h.

Referenced by LPSPI_SlaveTransferAbortEDMA(), LPSPI_SlaveTransferEDMA(), and LPSPI_SlaveTransferGetCountEDMA().

totalByteCount [1/2]

uint32_t _lpspi_master_edma_handle::totalByteCount

Number of transfer bytes

Definition at line 88 of file fsl_lpspi_edma.h.

Referenced by LPSPI_MasterTransferEDMA(), and LPSPI_MasterTransferGetCountEDMA().

totalByteCount [2/2]

uint32_t _lpspi_slave_edma_handle::totalByteCount

Number of transfer bytes

Definition at line 133 of file fsl_lpspi_edma.h.

Referenced by LPSPI_SlaveTransferEDMA(), and LPSPI_SlaveTransferGetCountEDMA().

transmitCommand

uint32_t _lpspi_master_edma_handle::transmitCommand

Used to write TCR for DMA purpose.

Definition at line 93 of file fsl_lpspi_edma.h.

Referenced by LPSPI_MasterTransferEDMA().

txBuffIfNull [1/2]

uint32_t _lpspi_master_edma_handle::txBuffIfNull

Used if there is not txData for DMA purpose.

Definition at line 90 of file fsl_lpspi_edma.h.

Referenced by LPSPI_MasterTransferEDMA().

txBuffIfNull [2/2]

uint32_t _lpspi_slave_edma_handle::txBuffIfNull

Used if there is not txData for DMA purpose.

Definition at line 135 of file fsl_lpspi_edma.h.

Referenced by LPSPI_SlaveTransferEDMA().

txData [1/2]

uint8_t* volatile _lpspi_master_edma_handle::txData

Send buffer.

Definition at line 80 of file fsl_lpspi_edma.h.

Referenced by LPSPI_MasterTransferEDMA().

txData [2/2]

uint8_t* volatile _lpspi_slave_edma_handle::txData

Send buffer.

Definition at line 125 of file fsl_lpspi_edma.h.

Referenced by LPSPI_SlaveTransferEDMA().

txRemainingByteCount [1/2]

volatile size_t _lpspi_master_edma_handle::txRemainingByteCount

Number of bytes remaining to send.

Definition at line 82 of file fsl_lpspi_edma.h.

Referenced by LPSPI_MasterTransferEDMA().

txRemainingByteCount [2/2]

volatile size_t _lpspi_slave_edma_handle::txRemainingByteCount

Number of bytes remaining to send.

Definition at line 127 of file fsl_lpspi_edma.h.

Referenced by LPSPI_SlaveTransferEDMA().

userData [1/2]

void* _lpspi_master_edma_handle::userData

Callback user data.

Definition at line 100 of file fsl_lpspi_edma.h.

Referenced by LPSPI_MasterTransferCreateHandleEDMA().

userData [2/2]

void* _lpspi_slave_edma_handle::userData

Callback user data.

Definition at line 143 of file fsl_lpspi_edma.h.

Referenced by LPSPI_SlaveTransferCreateHandleEDMA().

writeRegRemainingTimes [1/2]

volatile uint32_t _lpspi_master_edma_handle::writeRegRemainingTimes

Write TDR register remaining times.

Definition at line 85 of file fsl_lpspi_edma.h.

Referenced by LPSPI_MasterTransferEDMA().

writeRegRemainingTimes [2/2]

volatile uint32_t _lpspi_slave_edma_handle::writeRegRemainingTimes

Write TDR register remaining times.

Definition at line 130 of file fsl_lpspi_edma.h.

Referenced by LPSPI_SlaveTransferEDMA().