Data Structures
struct	_edma_config
	eDMA global configuration structure. More...

struct	_edma_transfer_config
	eDMA transfer configuration More...

struct	_edma_channel_Preemption_config
	eDMA channel priority configuration More...

struct	_edma_minor_offset_config
	eDMA minor offset configuration More...

struct	_edma_tcd
	eDMA TCD. More...

struct	_edma_handle
	eDMA transfer handle structure More...

Variables
bool	_edma_config::enableContinuousLinkMode

bool	_edma_config::enableHaltOnError

bool	_edma_config::enableRoundRobinArbitration

bool	_edma_config::enableDebugMode

uint32_t	_edma_transfer_config::srcAddr

uint32_t	_edma_transfer_config::destAddr

edma_transfer_size_t	_edma_transfer_config::srcTransferSize

edma_transfer_size_t	_edma_transfer_config::destTransferSize

int16_t	_edma_transfer_config::srcOffset

int16_t	_edma_transfer_config::destOffset

uint32_t	_edma_transfer_config::minorLoopBytes

uint32_t	_edma_transfer_config::majorLoopCounts

bool	_edma_channel_Preemption_config::enableChannelPreemption

bool	_edma_channel_Preemption_config::enablePreemptAbility

uint8_t	_edma_channel_Preemption_config::channelPriority

bool	_edma_minor_offset_config::enableSrcMinorOffset

bool	_edma_minor_offset_config::enableDestMinorOffset

uint32_t	_edma_minor_offset_config::minorOffset

__IO uint32_t	_edma_tcd::SADDR

__IO uint16_t	_edma_tcd::SOFF

__IO uint16_t	_edma_tcd::ATTR

__IO uint32_t	_edma_tcd::NBYTES

__IO uint32_t	_edma_tcd::SLAST

__IO uint32_t	_edma_tcd::DADDR

__IO uint16_t	_edma_tcd::DOFF

__IO uint16_t	_edma_tcd::CITER

__IO uint32_t	_edma_tcd::DLAST_SGA

__IO uint16_t	_edma_tcd::CSR

__IO uint16_t	_edma_tcd::BITER

edma_callback	_edma_handle::callback

void *	_edma_handle::userData

DMA_Type *	_edma_handle::base

edma_tcd_t *	_edma_handle::tcdPool

uint8_t	_edma_handle::channel

volatile int8_t	_edma_handle::header

volatile int8_t	_edma_handle::tail

volatile int8_t	_edma_handle::tcdUsed

volatile int8_t	_edma_handle::tcdSize

uint8_t	_edma_handle::flags

Driver version
enum	_edma_transfer_size { kEDMA_TransferSize1Bytes = 0x0U , kEDMA_TransferSize2Bytes = 0x1U , kEDMA_TransferSize4Bytes = 0x2U , kEDMA_TransferSize8Bytes = 0x3U , kEDMA_TransferSize16Bytes = 0x4U , kEDMA_TransferSize32Bytes = 0x5U }
	eDMA transfer configuration More...

enum	_edma_modulo { kEDMA_ModuloDisable = 0x0U , kEDMA_Modulo2bytes , kEDMA_Modulo4bytes , kEDMA_Modulo8bytes , kEDMA_Modulo16bytes , kEDMA_Modulo32bytes , kEDMA_Modulo64bytes , kEDMA_Modulo128bytes , kEDMA_Modulo256bytes , kEDMA_Modulo512bytes , kEDMA_Modulo1Kbytes , kEDMA_Modulo2Kbytes , kEDMA_Modulo4Kbytes , kEDMA_Modulo8Kbytes , kEDMA_Modulo16Kbytes , kEDMA_Modulo32Kbytes , kEDMA_Modulo64Kbytes , kEDMA_Modulo128Kbytes , kEDMA_Modulo256Kbytes , kEDMA_Modulo512Kbytes , kEDMA_Modulo1Mbytes , kEDMA_Modulo2Mbytes , kEDMA_Modulo4Mbytes , kEDMA_Modulo8Mbytes , kEDMA_Modulo16Mbytes , kEDMA_Modulo32Mbytes , kEDMA_Modulo64Mbytes , kEDMA_Modulo128Mbytes , kEDMA_Modulo256Mbytes , kEDMA_Modulo512Mbytes , kEDMA_Modulo1Gbytes , kEDMA_Modulo2Gbytes }
	eDMA modulo configuration More...

enum	_edma_bandwidth { kEDMA_BandwidthStallNone = 0x0U , kEDMA_BandwidthStall4Cycle = 0x2U , kEDMA_BandwidthStall8Cycle = 0x3U }
	Bandwidth control. More...

enum	_edma_channel_link_type { kEDMA_LinkNone = 0x0U , kEDMA_MinorLink , kEDMA_MajorLink }
	Channel link type. More...

enum	_edma_channel_status_flags { kEDMA_DoneFlag = 0x1U , kEDMA_ErrorFlag = 0x2U , kEDMA_InterruptFlag = 0x4U }
	eDMA channel status flags. More...

enum	_edma_error_status_flags { kEDMA_DestinationBusErrorFlag = DMA_ES_DBE_MASK , kEDMA_SourceBusErrorFlag = DMA_ES_SBE_MASK , kEDMA_ScatterGatherErrorFlag = DMA_ES_SGE_MASK , kEDMA_NbytesErrorFlag = DMA_ES_NCE_MASK , kEDMA_DestinationOffsetErrorFlag = DMA_ES_DOE_MASK , kEDMA_DestinationAddressErrorFlag = DMA_ES_DAE_MASK , kEDMA_SourceOffsetErrorFlag = DMA_ES_SOE_MASK , kEDMA_SourceAddressErrorFlag = DMA_ES_SAE_MASK , kEDMA_ErrorChannelFlag = DMA_ES_ERRCHN_MASK , kEDMA_ChannelPriorityErrorFlag = DMA_ES_CPE_MASK , kEDMA_TransferCanceledFlag = DMA_ES_ECX_MASK , kEDMA_GroupPriorityErrorFlag = DMA_ES_GPE_MASK , kEDMA_ValidFlag = (int)DMA_ES_VLD_MASK }
	eDMA channel error status flags. More...

enum	_edma_interrupt_enable { kEDMA_ErrorInterruptEnable = 0x1U , kEDMA_MajorInterruptEnable = DMA_CSR_INTMAJOR_MASK , kEDMA_HalfInterruptEnable = DMA_CSR_INTHALF_MASK }
	eDMA interrupt source More...

enum	_edma_transfer_type { kEDMA_MemoryToMemory = 0x0U , kEDMA_PeripheralToMemory , kEDMA_MemoryToPeripheral }
	eDMA transfer type More...

enum	_edma_transfer_status { kStatus_EDMA_QueueFull = MAKE_STATUS(kStatusGroup_EDMA, 0) , kStatus_EDMA_Busy = MAKE_STATUS(kStatusGroup_EDMA, 1) }
	eDMA transfer status More...

typedef enum _edma_transfer_size	edma_transfer_size_t
	eDMA transfer configuration

typedef enum _edma_modulo	edma_modulo_t
	eDMA modulo configuration

typedef enum _edma_bandwidth	edma_bandwidth_t
	Bandwidth control.

typedef enum _edma_channel_link_type	edma_channel_link_type_t
	Channel link type.

typedef enum _edma_interrupt_enable	edma_interrupt_enable_t
	eDMA interrupt source

typedef enum _edma_transfer_type	edma_transfer_type_t
	eDMA transfer type

typedef struct _edma_config	edma_config_t
	eDMA global configuration structure.

typedef struct _edma_transfer_config	edma_transfer_config_t
	eDMA transfer configuration

typedef struct _edma_channel_Preemption_config	edma_channel_Preemption_config_t
	eDMA channel priority configuration

typedef struct _edma_minor_offset_config	edma_minor_offset_config_t
	eDMA minor offset configuration

typedef struct _edma_tcd	edma_tcd_t
	eDMA TCD.

typedef void(*	edma_callback) (struct _edma_handle handle, void userData, bool transferDone, uint32_t tcds)
	Define callback function for eDMA.

typedef struct _edma_handle	edma_handle_t
	eDMA transfer handle structure

eDMA initialization and de-initialization
void	EDMA_Init (DMA_Type base, const edma_config_t config)
	Initializes the eDMA peripheral.

void	EDMA_Deinit (DMA_Type *base)
	Deinitializes the eDMA peripheral.

void	EDMA_InstallTCD (DMA_Type base, uint32_t channel, edma_tcd_t tcd)
	Push content of TCD structure into hardware TCD register.

void	EDMA_GetDefaultConfig (edma_config_t *config)
	Gets the eDMA default configuration structure.

eDMA Channel Operation
void	EDMA_ResetChannel (DMA_Type *base, uint32_t channel)
	Sets all TCD registers to default values.

void	EDMA_SetTransferConfig (DMA_Type base, uint32_t channel, const edma_transfer_config_t config, edma_tcd_t *nextTcd)
	Configures the eDMA transfer attribute.

void	EDMA_SetMinorOffsetConfig (DMA_Type base, uint32_t channel, const edma_minor_offset_config_t config)
	Configures the eDMA minor offset feature.

static void	EDMA_SetChannelPreemptionConfig (DMA_Type base, uint32_t channel, const edma_channel_Preemption_config_t config)
	Configures the eDMA channel preemption feature.

void	EDMA_SetChannelLink (DMA_Type *base, uint32_t channel, edma_channel_link_type_t type, uint32_t linkedChannel)
	Sets the channel link for the eDMA transfer.

void	EDMA_SetBandWidth (DMA_Type *base, uint32_t channel, edma_bandwidth_t bandWidth)
	Sets the bandwidth for the eDMA transfer.

void	EDMA_SetModulo (DMA_Type *base, uint32_t channel, edma_modulo_t srcModulo, edma_modulo_t destModulo)
	Sets the source modulo and the destination modulo for the eDMA transfer.

static void	EDMA_EnableAsyncRequest (DMA_Type *base, uint32_t channel, bool enable)
	Enables an async request for the eDMA transfer.

static void	EDMA_EnableAutoStopRequest (DMA_Type *base, uint32_t channel, bool enable)
	Enables an auto stop request for the eDMA transfer.

void	EDMA_EnableChannelInterrupts (DMA_Type *base, uint32_t channel, uint32_t mask)
	Enables the interrupt source for the eDMA transfer.

void	EDMA_DisableChannelInterrupts (DMA_Type *base, uint32_t channel, uint32_t mask)
	Disables the interrupt source for the eDMA transfer.

eDMA TCD Operation
void	EDMA_TcdReset (edma_tcd_t *tcd)
	Sets all fields to default values for the TCD structure.

void	EDMA_TcdSetTransferConfig (edma_tcd_t tcd, const edma_transfer_config_t config, edma_tcd_t *nextTcd)
	Configures the eDMA TCD transfer attribute.

void	EDMA_TcdSetMinorOffsetConfig (edma_tcd_t tcd, const edma_minor_offset_config_t config)
	Configures the eDMA TCD minor offset feature.

void	EDMA_TcdSetChannelLink (edma_tcd_t *tcd, edma_channel_link_type_t type, uint32_t linkedChannel)
	Sets the channel link for the eDMA TCD.

static void	EDMA_TcdSetBandWidth (edma_tcd_t *tcd, edma_bandwidth_t bandWidth)
	Sets the bandwidth for the eDMA TCD.

void	EDMA_TcdSetModulo (edma_tcd_t *tcd, edma_modulo_t srcModulo, edma_modulo_t destModulo)
	Sets the source modulo and the destination modulo for the eDMA TCD.

static void	EDMA_TcdEnableAutoStopRequest (edma_tcd_t *tcd, bool enable)
	Sets the auto stop request for the eDMA TCD.

void	EDMA_TcdEnableInterrupts (edma_tcd_t *tcd, uint32_t mask)
	Enables the interrupt source for the eDMA TCD.

void	EDMA_TcdDisableInterrupts (edma_tcd_t *tcd, uint32_t mask)
	Disables the interrupt source for the eDMA TCD.

eDMA Channel Transfer Operation
static void	EDMA_EnableChannelRequest (DMA_Type *base, uint32_t channel)
	Enables the eDMA hardware channel request.

static void	EDMA_DisableChannelRequest (DMA_Type *base, uint32_t channel)
	Disables the eDMA hardware channel request.

static void	EDMA_TriggerChannelStart (DMA_Type *base, uint32_t channel)
	Starts the eDMA transfer by using the software trigger.

eDMA Channel Status Operation
uint32_t	EDMA_GetRemainingMajorLoopCount (DMA_Type *base, uint32_t channel)
	Gets the remaining major loop count from the eDMA current channel TCD.

static uint32_t	EDMA_GetErrorStatusFlags (DMA_Type *base)
	Gets the eDMA channel error status flags.

uint32_t	EDMA_GetChannelStatusFlags (DMA_Type *base, uint32_t channel)
	Gets the eDMA channel status flags.

void	EDMA_ClearChannelStatusFlags (DMA_Type *base, uint32_t channel, uint32_t mask)
	Clears the eDMA channel status flags.

eDMA Transactional Operation
void	EDMA_CreateHandle (edma_handle_t handle, DMA_Type base, uint32_t channel)
	Creates the eDMA handle.

void	EDMA_InstallTCDMemory (edma_handle_t handle, edma_tcd_t tcdPool, uint32_t tcdSize)
	Installs the TCDs memory pool into the eDMA handle.

void	EDMA_SetCallback (edma_handle_t handle, edma_callback callback, void userData)
	Installs a callback function for the eDMA transfer.

void	EDMA_PrepareTransfer (edma_transfer_config_t config, void srcAddr, uint32_t srcWidth, void *destAddr, uint32_t destWidth, uint32_t bytesEachRequest, uint32_t transferBytes, edma_transfer_type_t type)
	Prepares the eDMA transfer structure.

status_t	EDMA_SubmitTransfer (edma_handle_t handle, const edma_transfer_config_t config)
	Submits the eDMA transfer request.

void	EDMA_StartTransfer (edma_handle_t *handle)
	eDMA starts transfer.

void	EDMA_StopTransfer (edma_handle_t *handle)
	eDMA stops transfer.

void	EDMA_AbortTransfer (edma_handle_t *handle)
	eDMA aborts transfer.

static uint32_t	EDMA_GetUnusedTCDNumber (edma_handle_t *handle)
	Get unused TCD slot number.

static uint32_t	EDMA_GetNextTCDAddress (edma_handle_t *handle)
	Get the next tcd address.

void	EDMA_HandleIRQ (edma_handle_t *handle)
	eDMA IRQ handler for the current major loop transfer completion.

Detailed Description

Typedef Documentation

◆ edma_bandwidth_t

typedef enum _edma_bandwidth edma_bandwidth_t

Bandwidth control.

◆ edma_callback

typedef void(* edma_callback) (struct _edma_handle *handle, void *userData, bool transferDone, uint32_t tcds)

Define callback function for eDMA.

This callback function is called in the EDMA interrupt handle. In normal mode, run into callback function means the transfer users need is done. In scatter gather mode, run into callback function means a transfer control block (tcd) is finished. Not all transfer finished, users can get the finished tcd numbers using interface EDMA_GetUnusedTCDNumber.

Parameters

handle	EDMA handle pointer, users shall not touch the values inside.
userData	The callback user parameter pointer. Users can use this parameter to involve things users need to change in EDMA callback function.
transferDone	If the current loaded transfer done. In normal mode it means if all transfer done. In scatter gather mode, this parameter shows is the current transfer block in EDMA register is done. As the load of core is different, it will be different if the new tcd loaded into EDMA registers while this callback called. If true, it always means new tcd still not loaded into registers, while false means new tcd already loaded into registers.
tcds	How many tcds are done from the last callback. This parameter only used in scatter gather mode. It tells user how many tcds are finished between the last callback and this.

Definition at line 242 of file fsl_edma.h.

◆ edma_channel_link_type_t

typedef enum _edma_channel_link_type edma_channel_link_type_t

Channel link type.

◆ edma_channel_Preemption_config_t

typedef struct _edma_channel_Preemption_config edma_channel_Preemption_config_t

eDMA channel priority configuration

◆ edma_config_t

typedef struct _edma_config edma_config_t

eDMA global configuration structure.

◆ edma_handle_t

typedef struct _edma_handle edma_handle_t

eDMA transfer handle structure

◆ edma_interrupt_enable_t

typedef enum _edma_interrupt_enable edma_interrupt_enable_t

eDMA interrupt source

◆ edma_minor_offset_config_t

typedef struct _edma_minor_offset_config edma_minor_offset_config_t

eDMA minor offset configuration

◆ edma_modulo_t

typedef enum _edma_modulo edma_modulo_t

eDMA modulo configuration

◆ edma_tcd_t

typedef struct _edma_tcd edma_tcd_t

eDMA TCD.

This structure is same as TCD register which is described in reference manual, and is used to configure the scatter/gather feature as a next hardware TCD.

◆ edma_transfer_config_t

typedef struct _edma_transfer_config edma_transfer_config_t

eDMA transfer configuration

This structure configures the source/destination transfer attribute.

◆ edma_transfer_size_t

typedef enum _edma_transfer_size edma_transfer_size_t

eDMA transfer configuration

◆ edma_transfer_type_t

typedef enum _edma_transfer_type edma_transfer_type_t

eDMA transfer type

Enumeration Type Documentation

◆ _edma_bandwidth

enum _edma_bandwidth

Bandwidth control.

Enumerator
kEDMA_BandwidthStallNone	No eDMA engine stalls.
kEDMA_BandwidthStall4Cycle	eDMA engine stalls for 4 cycles after each read/write.
kEDMA_BandwidthStall8Cycle	eDMA engine stalls for 8 cycles after each read/write.

Definition at line 84 of file fsl_edma.h.

{
    kEDMA_BandwidthStallNone = 0x0U,   /*!< No eDMA engine stalls. */
    kEDMA_BandwidthStall4Cycle = 0x2U, /*!< eDMA engine stalls for 4 cycles after each read/write. */
    kEDMA_BandwidthStall8Cycle = 0x3U, /*!< eDMA engine stalls for 8 cycles after each read/write. */
} edma_bandwidth_t;

◆ _edma_channel_link_type

enum _edma_channel_link_type

Channel link type.

Enumerator
kEDMA_LinkNone	No channel link
kEDMA_MinorLink	Channel link after each minor loop
kEDMA_MajorLink	Channel link while major loop count exhausted

Definition at line 92 of file fsl_edma.h.

{
    kEDMA_LinkNone = 0x0U, /*!< No channel link  */
    kEDMA_MinorLink,       /*!< Channel link after each minor loop */
    kEDMA_MajorLink,       /*!< Channel link while major loop count exhausted */
} edma_channel_link_type_t;

◆ _edma_channel_status_flags

enum _edma_channel_status_flags

eDMA channel status flags.

Enumerator
kEDMA_DoneFlag	DONE flag, set while transfer finished, CITER value exhausted
kEDMA_ErrorFlag	eDMA error flag, an error occurred in a transfer
kEDMA_InterruptFlag	eDMA interrupt flag, set while an interrupt occurred of this channel

Definition at line 100 of file fsl_edma.h.

{
    kEDMA_DoneFlag = 0x1U,      /*!< DONE flag, set while transfer finished, CITER value exhausted*/
    kEDMA_ErrorFlag = 0x2U,     /*!< eDMA error flag, an error occurred in a transfer */
    kEDMA_InterruptFlag = 0x4U, /*!< eDMA interrupt flag, set while an interrupt occurred of this channel */
};

◆ _edma_error_status_flags

enum _edma_error_status_flags

eDMA channel error status flags.

Enumerator
kEDMA_DestinationBusErrorFlag	Bus error on destination address
kEDMA_SourceBusErrorFlag	Bus error on the source address
kEDMA_ScatterGatherErrorFlag	Error on the Scatter/Gather address, not 32byte aligned.
kEDMA_NbytesErrorFlag	NBYTES/CITER configuration error
kEDMA_DestinationOffsetErrorFlag	Destination offset not aligned with destination size
kEDMA_DestinationAddressErrorFlag	Destination address not aligned with destination size
kEDMA_SourceOffsetErrorFlag	Source offset not aligned with source size
kEDMA_SourceAddressErrorFlag	Source address not aligned with source size
kEDMA_ErrorChannelFlag	Error channel number of the cancelled channel number
kEDMA_ChannelPriorityErrorFlag	Channel priority is not unique.
kEDMA_TransferCanceledFlag	Transfer cancelled
kEDMA_GroupPriorityErrorFlag	Group priority is not unique.
kEDMA_ValidFlag	No error occurred, this bit is 0. Otherwise, it is 1.

Definition at line 108 of file fsl_edma.h.

{
    kEDMA_DestinationBusErrorFlag = DMA_ES_DBE_MASK,    /*!< Bus error on destination address */
    kEDMA_SourceBusErrorFlag = DMA_ES_SBE_MASK,         /*!< Bus error on the source address */
    kEDMA_ScatterGatherErrorFlag = DMA_ES_SGE_MASK,     /*!< Error on the Scatter/Gather address, not 32byte aligned. */
    kEDMA_NbytesErrorFlag = DMA_ES_NCE_MASK,            /*!< NBYTES/CITER configuration error */
    kEDMA_DestinationOffsetErrorFlag = DMA_ES_DOE_MASK, /*!< Destination offset not aligned with destination size */
    kEDMA_DestinationAddressErrorFlag = DMA_ES_DAE_MASK, /*!< Destination address not aligned with destination size */
    kEDMA_SourceOffsetErrorFlag = DMA_ES_SOE_MASK,       /*!< Source offset not aligned with source size */
    kEDMA_SourceAddressErrorFlag = DMA_ES_SAE_MASK,      /*!< Source address not aligned with source size*/
    kEDMA_ErrorChannelFlag = DMA_ES_ERRCHN_MASK,         /*!< Error channel number of the cancelled channel number */
    kEDMA_ChannelPriorityErrorFlag = DMA_ES_CPE_MASK,    /*!< Channel priority is not unique. */
    kEDMA_TransferCanceledFlag = DMA_ES_ECX_MASK,        /*!< Transfer cancelled */
#if defined(FSL_FEATURE_EDMA_CHANNEL_GROUP_COUNT) && FSL_FEATURE_EDMA_CHANNEL_GROUP_COUNT > 1
    kEDMA_GroupPriorityErrorFlag = DMA_ES_GPE_MASK, /*!< Group priority is not unique. */
#endif
    kEDMA_ValidFlag = (int)DMA_ES_VLD_MASK, /*!< No error occurred, this bit is 0. Otherwise, it is 1. */
};

◆ _edma_interrupt_enable

enum _edma_interrupt_enable

eDMA interrupt source

Enumerator
kEDMA_ErrorInterruptEnable	Enable interrupt while channel error occurs.
kEDMA_MajorInterruptEnable	Enable interrupt while major count exhausted.
kEDMA_HalfInterruptEnable	Enable interrupt while major count to half value.

Definition at line 128 of file fsl_edma.h.

{
    kEDMA_ErrorInterruptEnable = 0x1U,                  /*!< Enable interrupt while channel error occurs. */
    kEDMA_MajorInterruptEnable = DMA_CSR_INTMAJOR_MASK, /*!< Enable interrupt while major count exhausted. */
    kEDMA_HalfInterruptEnable = DMA_CSR_INTHALF_MASK,   /*!< Enable interrupt while major count to half value. */
} edma_interrupt_enable_t;

◆ _edma_modulo

enum _edma_modulo

eDMA modulo configuration

Enumerator
kEDMA_ModuloDisable	Disable modulo
kEDMA_Modulo2bytes	Circular buffer size is 2 bytes.
kEDMA_Modulo4bytes	Circular buffer size is 4 bytes.
kEDMA_Modulo8bytes	Circular buffer size is 8 bytes.
kEDMA_Modulo16bytes	Circular buffer size is 16 bytes.
kEDMA_Modulo32bytes	Circular buffer size is 32 bytes.
kEDMA_Modulo64bytes	Circular buffer size is 64 bytes.
kEDMA_Modulo128bytes	Circular buffer size is 128 bytes.
kEDMA_Modulo256bytes	Circular buffer size is 256 bytes.
kEDMA_Modulo512bytes	Circular buffer size is 512 bytes.
kEDMA_Modulo1Kbytes	Circular buffer size is 1 K bytes.
kEDMA_Modulo2Kbytes	Circular buffer size is 2 K bytes.
kEDMA_Modulo4Kbytes	Circular buffer size is 4 K bytes.
kEDMA_Modulo8Kbytes	Circular buffer size is 8 K bytes.
kEDMA_Modulo16Kbytes	Circular buffer size is 16 K bytes.
kEDMA_Modulo32Kbytes	Circular buffer size is 32 K bytes.
kEDMA_Modulo64Kbytes	Circular buffer size is 64 K bytes.
kEDMA_Modulo128Kbytes	Circular buffer size is 128 K bytes.
kEDMA_Modulo256Kbytes	Circular buffer size is 256 K bytes.
kEDMA_Modulo512Kbytes	Circular buffer size is 512 K bytes.
kEDMA_Modulo1Mbytes	Circular buffer size is 1 M bytes.
kEDMA_Modulo2Mbytes	Circular buffer size is 2 M bytes.
kEDMA_Modulo4Mbytes	Circular buffer size is 4 M bytes.
kEDMA_Modulo8Mbytes	Circular buffer size is 8 M bytes.
kEDMA_Modulo16Mbytes	Circular buffer size is 16 M bytes.
kEDMA_Modulo32Mbytes	Circular buffer size is 32 M bytes.
kEDMA_Modulo64Mbytes	Circular buffer size is 64 M bytes.
kEDMA_Modulo128Mbytes	Circular buffer size is 128 M bytes.
kEDMA_Modulo256Mbytes	Circular buffer size is 256 M bytes.
kEDMA_Modulo512Mbytes	Circular buffer size is 512 M bytes.
kEDMA_Modulo1Gbytes	Circular buffer size is 1 G bytes.
kEDMA_Modulo2Gbytes	Circular buffer size is 2 G bytes.

Definition at line 47 of file fsl_edma.h.

{
    kEDMA_ModuloDisable = 0x0U, /*!< Disable modulo */
    kEDMA_Modulo2bytes,         /*!< Circular buffer size is 2 bytes. */
    kEDMA_Modulo4bytes,         /*!< Circular buffer size is 4 bytes. */
    kEDMA_Modulo8bytes,         /*!< Circular buffer size is 8 bytes. */
    kEDMA_Modulo16bytes,        /*!< Circular buffer size is 16 bytes. */
    kEDMA_Modulo32bytes,        /*!< Circular buffer size is 32 bytes. */
    kEDMA_Modulo64bytes,        /*!< Circular buffer size is 64 bytes. */
    kEDMA_Modulo128bytes,       /*!< Circular buffer size is 128 bytes. */
    kEDMA_Modulo256bytes,       /*!< Circular buffer size is 256 bytes. */
    kEDMA_Modulo512bytes,       /*!< Circular buffer size is 512 bytes. */
    kEDMA_Modulo1Kbytes,        /*!< Circular buffer size is 1 K bytes. */
    kEDMA_Modulo2Kbytes,        /*!< Circular buffer size is 2 K bytes. */
    kEDMA_Modulo4Kbytes,        /*!< Circular buffer size is 4 K bytes. */
    kEDMA_Modulo8Kbytes,        /*!< Circular buffer size is 8 K bytes. */
    kEDMA_Modulo16Kbytes,       /*!< Circular buffer size is 16 K bytes. */
    kEDMA_Modulo32Kbytes,       /*!< Circular buffer size is 32 K bytes. */
    kEDMA_Modulo64Kbytes,       /*!< Circular buffer size is 64 K bytes. */
    kEDMA_Modulo128Kbytes,      /*!< Circular buffer size is 128 K bytes. */
    kEDMA_Modulo256Kbytes,      /*!< Circular buffer size is 256 K bytes. */
    kEDMA_Modulo512Kbytes,      /*!< Circular buffer size is 512 K bytes. */
    kEDMA_Modulo1Mbytes,        /*!< Circular buffer size is 1 M bytes. */
    kEDMA_Modulo2Mbytes,        /*!< Circular buffer size is 2 M bytes. */
    kEDMA_Modulo4Mbytes,        /*!< Circular buffer size is 4 M bytes. */
    kEDMA_Modulo8Mbytes,        /*!< Circular buffer size is 8 M bytes. */
    kEDMA_Modulo16Mbytes,       /*!< Circular buffer size is 16 M bytes. */
    kEDMA_Modulo32Mbytes,       /*!< Circular buffer size is 32 M bytes. */
    kEDMA_Modulo64Mbytes,       /*!< Circular buffer size is 64 M bytes. */
    kEDMA_Modulo128Mbytes,      /*!< Circular buffer size is 128 M bytes. */
    kEDMA_Modulo256Mbytes,      /*!< Circular buffer size is 256 M bytes. */
    kEDMA_Modulo512Mbytes,      /*!< Circular buffer size is 512 M bytes. */
    kEDMA_Modulo1Gbytes,        /*!< Circular buffer size is 1 G bytes. */
    kEDMA_Modulo2Gbytes,        /*!< Circular buffer size is 2 G bytes. */
} edma_modulo_t;

◆ _edma_transfer_size

enum _edma_transfer_size

eDMA transfer configuration

Enumerator
kEDMA_TransferSize1Bytes	Source/Destination data transfer size is 1 byte every time
kEDMA_TransferSize2Bytes	Source/Destination data transfer size is 2 bytes every time
kEDMA_TransferSize4Bytes	Source/Destination data transfer size is 4 bytes every time
kEDMA_TransferSize8Bytes	Source/Destination data transfer size is 8 bytes every time
kEDMA_TransferSize16Bytes	Source/Destination data transfer size is 16 bytes every time
kEDMA_TransferSize32Bytes	Source/Destination data transfer size is 32 bytes every time

Definition at line 36 of file fsl_edma.h.

{
    kEDMA_TransferSize1Bytes = 0x0U,  /*!< Source/Destination data transfer size is 1 byte every time */
    kEDMA_TransferSize2Bytes = 0x1U,  /*!< Source/Destination data transfer size is 2 bytes every time */
    kEDMA_TransferSize4Bytes = 0x2U,  /*!< Source/Destination data transfer size is 4 bytes every time */
    kEDMA_TransferSize8Bytes = 0x3U,  /*!< Source/Destination data transfer size is 8 bytes every time */
    kEDMA_TransferSize16Bytes = 0x4U, /*!< Source/Destination data transfer size is 16 bytes every time */
    kEDMA_TransferSize32Bytes = 0x5U, /*!< Source/Destination data transfer size is 32 bytes every time */
} edma_transfer_size_t;

◆ _edma_transfer_status

enum _edma_transfer_status

eDMA transfer status

Enumerator
kStatus_EDMA_QueueFull	TCD queue is full.
kStatus_EDMA_Busy	Channel is busy and can't handle the transfer request.

Definition at line 144 of file fsl_edma.h.

{
    kStatus_EDMA_QueueFull = MAKE_STATUS(kStatusGroup_EDMA, 0), /*!< TCD queue is full. */
    kStatus_EDMA_Busy = MAKE_STATUS(kStatusGroup_EDMA, 1),      /*!< Channel is busy and can't handle the
                                                                     transfer request. */
};

◆ _edma_transfer_type

enum _edma_transfer_type

eDMA transfer type

Enumerator
kEDMA_MemoryToMemory	Transfer from memory to memory
kEDMA_PeripheralToMemory	Transfer from peripheral to memory
kEDMA_MemoryToPeripheral	Transfer from memory to peripheral

Definition at line 136 of file fsl_edma.h.

{
    kEDMA_MemoryToMemory = 0x0U, /*!< Transfer from memory to memory */
    kEDMA_PeripheralToMemory,    /*!< Transfer from peripheral to memory */
    kEDMA_MemoryToPeripheral,    /*!< Transfer from memory to peripheral */
} edma_transfer_type_t;

Function Documentation

◆ EDMA_AbortTransfer()

void EDMA_AbortTransfer ( edma_handle_t * handle )

eDMA aborts transfer.

This function disables the channel request and clear transfer status bits. Users can submit another transfer after calling this API.

Parameters

handle DMA handle pointer.

brief eDMA aborts transfer.

This function disables the channel request and clear transfer status bits. Users can submit another transfer after calling this API.

param handle DMA handle pointer.

Definition at line 1164 of file fsl_edma.c.

{
    handle->base->CERQ = DMA_CERQ_CERQ(handle->channel);
    /*
        Clear CSR to release channel. Because if the given channel started transfer,
        CSR will be not zero. Because if it is the last transfer, DREQ will be set.
        If not, ESG will be set.
    */
    handle->base->TCD[handle->channel].CSR = 0;
    /* Cancel all next TCD transfer. */
    handle->base->TCD[handle->channel].DLAST_SGA = 0;
 
    /* Handle the tcd */
    if (handle->tcdPool != NULL)
    {
        handle->header = 0;
        handle->tail = 0;
        handle->tcdUsed = 0;
    }
}

Referenced by LPSPI_MasterTransferAbortEDMA(), LPSPI_SlaveTransferAbortEDMA(), LPUART_TransferAbortReceiveEDMA(), and LPUART_TransferAbortSendEDMA().

Here is the caller graph for this function:

◆ EDMA_ClearChannelStatusFlags()

void EDMA_ClearChannelStatusFlags	(	DMA_Type *	base,
		uint32_t	channel,
		uint32_t	mask
	)

Clears the eDMA channel status flags.

Parameters

base	eDMA peripheral base address.
channel	eDMA channel number.
mask	The mask of channel status to be cleared. Users need to use the defined _edma_channel_status_flags type.

brief Clears the eDMA channel status flags.

param base eDMA peripheral base address. param channel eDMA channel number. param mask The mask of channel status to be cleared. Users need to use the defined _edma_channel_status_flags type.

Definition at line 708 of file fsl_edma.c.

{
    assert(channel < FSL_FEATURE_EDMA_MODULE_CHANNEL);
 
    /* Clear DONE bit flag */
    if (mask & kEDMA_DoneFlag)
    {
        base->CDNE = channel;
    }
    /* Clear ERROR bit flag */
    if (mask & kEDMA_ErrorFlag)
    {
        base->CERR = channel;
    }
    /* Clear INT bit flag */
    if (mask & kEDMA_InterruptFlag)
    {
        base->CINT = channel;
    }
}

◆ EDMA_CreateHandle()

void EDMA_CreateHandle	(	edma_handle_t *	handle,
		DMA_Type *	base,
		uint32_t	channel
	)

Creates the eDMA handle.

This function is called if using the transactional API for eDMA. This function initializes the internal state of the eDMA handle.

Parameters

handle	eDMA handle pointer. The eDMA handle stores callback function and parameters.
base	eDMA peripheral base address.
channel	eDMA channel number.

brief Creates the eDMA handle.

This function is called if using the transactional API for eDMA. This function initializes the internal state of the eDMA handle.

param handle eDMA handle pointer. The eDMA handle stores callback function and parameters. param base eDMA peripheral base address. param channel eDMA channel number.

Definition at line 757 of file fsl_edma.c.

{
    assert(handle != NULL);
    assert(channel < FSL_FEATURE_EDMA_MODULE_CHANNEL);
 
    uint32_t edmaInstance;
    uint32_t channelIndex;
    uint8_t StartInstance;
    edma_tcd_t *tcdRegs;
 
    /* Zero the handle */
    memset(handle, 0, sizeof(*handle));
 
    handle->base = base;
    handle->channel = channel;
    /* Get the DMA instance number */
    edmaInstance = EDMA_GetInstance(base);
    StartInstance = Get_StartInstance();
    channelIndex = ((edmaInstance - StartInstance) * FSL_FEATURE_EDMA_MODULE_CHANNEL) + channel;
    s_EDMAHandle[channelIndex] = handle;
 
    /* Enable NVIC interrupt */
    EnableIRQ(s_edmaIRQNumber[edmaInstance][channel]);
 
    /*
       Reset TCD registers to zero. Unlike the EDMA_TcdReset(DREQ will be set),
       CSR will be 0. Because in order to suit EDMA busy check mechanism in
       EDMA_SubmitTransfer, CSR must be set 0.
    */
    tcdRegs = (edma_tcd_t *)&handle->base->TCD[handle->channel];
    tcdRegs->SADDR = 0;
    tcdRegs->SOFF = 0;
    tcdRegs->ATTR = 0;
    tcdRegs->NBYTES = 0;
    tcdRegs->SLAST = 0;
    tcdRegs->DADDR = 0;
    tcdRegs->DOFF = 0;
    tcdRegs->CITER = 0;
    tcdRegs->DLAST_SGA = 0;
    tcdRegs->CSR = 0;
    tcdRegs->BITER = 0;
}

Referenced by uart_lld_start().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ EDMA_Deinit()

void EDMA_Deinit ( DMA_Type * base )

Deinitializes the eDMA peripheral.

This function gates the eDMA clock.

Parameters

base	eDMA peripheral base address.

brief Deinitializes the eDMA peripheral.

This function gates the eDMA clock.

param base eDMA peripheral base address.

Definition at line 143 of file fsl_edma.c.

{
#if !(defined(FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL) && FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL)
    /* Gate EDMA peripheral clock */
    CLOCK_DisableClock(s_edmaClockName[EDMA_GetInstance(base)]);
#endif /* FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL */
}

Here is the call graph for this function:

◆ EDMA_DisableChannelInterrupts()

void EDMA_DisableChannelInterrupts	(	DMA_Type *	base,
		uint32_t	channel,
		uint32_t	mask
	)

Disables the interrupt source for the eDMA transfer.

Parameters

base	eDMA peripheral base address.
channel	eDMA channel number.
mask	The mask of the interrupt source to be set. Use the defined edma_interrupt_enable_t type.

brief Disables the interrupt source for the eDMA transfer.

param base eDMA peripheral base address. param channel eDMA channel number. param mask The mask of the interrupt source to be set. Use the defined edma_interrupt_enable_t type.

Definition at line 361 of file fsl_edma.c.

{
    assert(channel < FSL_FEATURE_EDMA_MODULE_CHANNEL);
 
    /* Disable error interrupt */
    if (mask & kEDMA_ErrorInterruptEnable)
    {
        base->EEI &= ~(0x1U << channel);
    }
 
    /* Disable Major interrupt */
    if (mask & kEDMA_MajorInterruptEnable)
    {
        base->TCD[channel].CSR &= ~DMA_CSR_INTMAJOR_MASK;
    }
 
    /* Disable Half major interrupt */
    if (mask & kEDMA_HalfInterruptEnable)
    {
        base->TCD[channel].CSR &= ~DMA_CSR_INTHALF_MASK;
    }
}

◆ EDMA_DisableChannelRequest()

static void EDMA_DisableChannelRequest	(	DMA_Type *	base,
		uint32_t	channel
	)

inlinestatic

Disables the eDMA hardware channel request.

This function disables the hardware channel request.

Parameters

base	eDMA peripheral base address.
channel	eDMA channel number.

Definition at line 669 of file fsl_edma.h.

{
    assert(channel < FSL_FEATURE_DMAMUX_MODULE_CHANNEL);
 
    base->CERQ = DMA_CERQ_CERQ(channel);
}

◆ EDMA_EnableAsyncRequest()

static void EDMA_EnableAsyncRequest	(	DMA_Type *	base,
		uint32_t	channel,
		bool	enable
	)

inlinestatic

Enables an async request for the eDMA transfer.

Parameters

base	eDMA peripheral base address.
channel	eDMA channel number.
enable	The command to enable (true) or disable (false).

Definition at line 456 of file fsl_edma.h.

{
    assert(channel < FSL_FEATURE_DMAMUX_MODULE_CHANNEL);
 
    base->EARS = (base->EARS & (~(1U << channel))) | ((uint32_t)enable << channel);
}

Here is the call graph for this function:

◆ EDMA_EnableAutoStopRequest()

static void EDMA_EnableAutoStopRequest	(	DMA_Type *	base,
		uint32_t	channel,
		bool	enable
	)

inlinestatic

Enables an auto stop request for the eDMA transfer.

If enabling the auto stop request, the eDMA hardware automatically disables the hardware channel request.

Parameters

base	eDMA peripheral base address.
channel	eDMA channel number.
enable	The command to enable (true) or disable (false).

Definition at line 473 of file fsl_edma.h.

{
    assert(channel < FSL_FEATURE_DMAMUX_MODULE_CHANNEL);
 
    base->TCD[channel].CSR = (base->TCD[channel].CSR & (~DMA_CSR_DREQ_MASK)) | DMA_CSR_DREQ(enable);
}

Here is the call graph for this function:

◆ EDMA_EnableChannelInterrupts()

void EDMA_EnableChannelInterrupts	(	DMA_Type *	base,
		uint32_t	channel,
		uint32_t	mask
	)

Enables the interrupt source for the eDMA transfer.

Parameters

base	eDMA peripheral base address.
channel	eDMA channel number.
mask	The mask of interrupt source to be set. Users need to use the defined edma_interrupt_enable_t type.

brief Enables the interrupt source for the eDMA transfer.

param base eDMA peripheral base address. param channel eDMA channel number. param mask The mask of interrupt source to be set. Users need to use the defined edma_interrupt_enable_t type.

Definition at line 330 of file fsl_edma.c.

{
    assert(channel < FSL_FEATURE_EDMA_MODULE_CHANNEL);
 
    /* Enable error interrupt */
    if (mask & kEDMA_ErrorInterruptEnable)
    {
        base->EEI |= (0x1U << channel);
    }
 
    /* Enable Major interrupt */
    if (mask & kEDMA_MajorInterruptEnable)
    {
        base->TCD[channel].CSR |= DMA_CSR_INTMAJOR_MASK;
    }
 
    /* Enable Half major interrupt */
    if (mask & kEDMA_HalfInterruptEnable)
    {
        base->TCD[channel].CSR |= DMA_CSR_INTHALF_MASK;
    }
}

Referenced by LPSPI_MasterTransferEDMA(), and LPSPI_SlaveTransferEDMA().

Here is the caller graph for this function:

◆ EDMA_EnableChannelRequest()

static void EDMA_EnableChannelRequest	(	DMA_Type *	base,
		uint32_t	channel
	)

inlinestatic

Enables the eDMA hardware channel request.

This function enables the hardware channel request.

Parameters

base	eDMA peripheral base address.
channel	eDMA channel number.

Definition at line 654 of file fsl_edma.h.

{
    assert(channel < FSL_FEATURE_DMAMUX_MODULE_CHANNEL);
 
    base->SERQ = DMA_SERQ_SERQ(channel);
}

◆ EDMA_GetChannelStatusFlags()

uint32_t EDMA_GetChannelStatusFlags	(	DMA_Type *	base,
		uint32_t	channel
	)

Gets the eDMA channel status flags.

Parameters

base	eDMA peripheral base address.
channel	eDMA channel number.

Returns: The mask of channel status flags. Users need to use the _edma_channel_status_flags type to decode the return variables.

brief Gets the eDMA channel status flags.

param base eDMA peripheral base address. param channel eDMA channel number. return The mask of channel status flags. Users need to use the _edma_channel_status_flags type to decode the return variables.

Definition at line 684 of file fsl_edma.c.

{
    assert(channel < FSL_FEATURE_EDMA_MODULE_CHANNEL);
 
    uint32_t retval = 0;
 
    /* Get DONE bit flag */
    retval |= ((base->TCD[channel].CSR & DMA_CSR_DONE_MASK) >> DMA_CSR_DONE_SHIFT);
    /* Get ERROR bit flag */
    retval |= (((base->ERR >> channel) & 0x1U) << 1U);
    /* Get INT bit flag */
    retval |= (((base->INT >> channel) & 0x1U) << 2U);
 
    return retval;
}

◆ EDMA_GetDefaultConfig()

void EDMA_GetDefaultConfig ( edma_config_t * config )

Gets the eDMA default configuration structure.

This function sets the configuration structure to default values. The default configuration is set to the following values.

config.enableContinuousLinkMode = false;
config.enableHaltOnError = true;
config.enableRoundRobinArbitration = false;
config.enableDebugMode = false;

Parameters

config A pointer to the eDMA configuration structure.

brief Gets the eDMA default configuration structure.

This function sets the configuration structure to default values. The default configuration is set to the following values. code config.enableContinuousLinkMode = false; config.enableHaltOnError = true; config.enableRoundRobinArbitration = false; config.enableDebugMode = false; endcode

param config A pointer to the eDMA configuration structure.

Definition at line 165 of file fsl_edma.c.

{
    assert(config != NULL);
 
    /* Initializes the configure structure to zero. */
    memset(config, 0, sizeof(*config));
 
    config->enableRoundRobinArbitration = false;
    config->enableHaltOnError = true;
    config->enableContinuousLinkMode = false;
    config->enableDebugMode = false;
}

Referenced by dmaInit().

Here is the caller graph for this function:

◆ EDMA_GetErrorStatusFlags()

static uint32_t EDMA_GetErrorStatusFlags ( DMA_Type * base )

inlinestatic

Gets the eDMA channel error status flags.

Parameters

base	eDMA peripheral base address.

Returns: The mask of error status flags. Users need to use the _edma_error_status_flags type to decode the return variables.

Definition at line 727 of file fsl_edma.h.

{
    return base->ES;
}

◆ EDMA_GetNextTCDAddress()

static uint32_t EDMA_GetNextTCDAddress ( edma_handle_t * handle )

inlinestatic

Get the next tcd address.

This function gets the next tcd address. If this is last TCD, return 0.

Parameters

handle DMA handle pointer.

Returns: The next TCD address.

Definition at line 888 of file fsl_edma.h.

{
    return (handle->base->TCD[handle->channel].DLAST_SGA);
}

◆ EDMA_GetRemainingMajorLoopCount()

uint32_t EDMA_GetRemainingMajorLoopCount	(	DMA_Type *	base,
		uint32_t	channel
	)

Gets the remaining major loop count from the eDMA current channel TCD.

This function checks the TCD (Task Control Descriptor) status for a specified eDMA channel and returns the number of major loop count that has not finished.

Parameters

base	eDMA peripheral base address.
channel	eDMA channel number.

Returns: Major loop count which has not been transferred yet for the current TCD.

Note

1. This function can only be used to get unfinished major loop count of transfer without the next TCD, or it might be inaccuracy.

The unfinished/remaining transfer bytes cannot be obtained directly from registers while the channel is running. Because to calculate the remaining bytes, the initial NBYTES configured in DMA_TCDn_NBYTES_MLNO register is needed while the eDMA IP does not support getting it while a channel is active. In another word, the NBYTES value reading is always the actual (decrementing) NBYTES value the dma_engine is working with while a channel is running. Consequently, to get the remaining transfer bytes, a software-saved initial value of NBYTES (for example copied before enabling the channel) is needed. The formula to calculate it is shown below: RemainingBytes = RemainingMajorLoopCount * NBYTES(initially configured)

brief Gets the remaining major loop count from the eDMA current channel TCD.

This function checks the TCD (Task Control Descriptor) status for a specified eDMA channel and returns the number of major loop count that has not finished.

param base eDMA peripheral base address. param channel eDMA channel number. return Major loop count which has not been transferred yet for the current TCD. note 1. This function can only be used to get unfinished major loop count of transfer without the next TCD, or it might be inaccuracy.

The unfinished/remaining transfer bytes cannot be obtained directly from registers while the channel is running. Because to calculate the remaining bytes, the initial NBYTES configured in DMA_TCDn_NBYTES_MLNO register is needed while the eDMA IP does not support getting it while a channel is active. In another word, the NBYTES value reading is always the actual (decrementing) NBYTES value the dma_engine is working with while a channel is running. Consequently, to get the remaining transfer bytes, a software-saved initial value of NBYTES (for example copied before enabling the channel) is needed. The formula to calculate it is shown below: RemainingBytes = RemainingMajorLoopCount * NBYTES(initially configured)

Definition at line 648 of file fsl_edma.c.

{
    assert(channel < FSL_FEATURE_EDMA_MODULE_CHANNEL);
 
    uint32_t remainingCount = 0;
 
    if (DMA_CSR_DONE_MASK & base->TCD[channel].CSR)
    {
        remainingCount = 0;
    }
    else
    {
        /* Calculate the unfinished bytes */
        if (base->TCD[channel].CITER_ELINKNO & DMA_CITER_ELINKNO_ELINK_MASK)
        {
            remainingCount =
                (base->TCD[channel].CITER_ELINKYES & DMA_CITER_ELINKYES_CITER_MASK) >> DMA_CITER_ELINKYES_CITER_SHIFT;
        }
        else
        {
            remainingCount =
                (base->TCD[channel].CITER_ELINKNO & DMA_CITER_ELINKNO_CITER_MASK) >> DMA_CITER_ELINKNO_CITER_SHIFT;
        }
    }
 
    return remainingCount;
}

Referenced by LPSPI_MasterTransferGetCountEDMA(), LPSPI_SlaveTransferGetCountEDMA(), LPUART_TransferGetReceiveCountEDMA(), and LPUART_TransferGetSendCountEDMA().

Here is the caller graph for this function:

◆ EDMA_GetUnusedTCDNumber()

static uint32_t EDMA_GetUnusedTCDNumber ( edma_handle_t * handle )

inlinestatic

Get unused TCD slot number.

This function gets current tcd index which is run. If the TCD pool pointer is NULL, it will return 0.

Parameters

handle DMA handle pointer.

Returns: The unused tcd slot number.

Definition at line 875 of file fsl_edma.h.

{
    return (handle->tcdSize - handle->tcdUsed);
}

◆ EDMA_HandleIRQ()

void EDMA_HandleIRQ ( edma_handle_t * handle )

eDMA IRQ handler for the current major loop transfer completion.

This function clears the channel major interrupt flag and calls the callback function if it is not NULL.

Note: For the case using TCD queue, when the major iteration count is exhausted, additional operations are performed. These include the final address adjustments and reloading of the BITER field into the CITER. Assertion of an optional interrupt request also occurs at this time, as does a possible fetch of a new TCD from memory using the scatter/gather address pointer included in the descriptor (if scatter/gather is enabled).

For instance, when the time interrupt of TCD[0] happens, the TCD[1] has already been loaded into the eDMA engine. As sga and sga_index are calculated based on the DLAST_SGA bitfield lies in the TCD_CSR register, the sga_index in this case should be 2 (DLAST_SGA of TCD[1] stores the address of TCD[2]). Thus, the "tcdUsed" updated should be (tcdUsed - 2U) which indicates the number of TCDs can be loaded in the memory pool (because TCD[0] and TCD[1] have been loaded into the eDMA engine at this point already.).

For the last two continuous ISRs in a scatter/gather process, they both load the last TCD (The last ISR does not load a new TCD) from the memory pool to the eDMA engine when major loop completes. Therefore, ensure that the header and tcdUsed updated are identical for them. tcdUsed are both 0 in this case as no TCD to be loaded.

See the "eDMA basic data flow" in the eDMA Functional description section of the Reference Manual for further details.

Parameters

handle eDMA handle pointer.

brief eDMA IRQ handler for the current major loop transfer completion.

This function clears the channel major interrupt flag and calls the callback function if it is not NULL.

Note: For the case using TCD queue, when the major iteration count is exhausted, additional operations are performed. These include the final address adjustments and reloading of the BITER field into the CITER. Assertion of an optional interrupt request also occurs at this time, as does a possible fetch of a new TCD from memory using the scatter/gather address pointer included in the descriptor (if scatter/gather is enabled).

For instance, when the time interrupt of TCD[0] happens, the TCD[1] has already been loaded into the eDMA engine. As sga and sga_index are calculated based on the DLAST_SGA bitfield lies in the TCD_CSR register, the sga_index in this case should be 2 (DLAST_SGA of TCD[1] stores the address of TCD[2]). Thus, the "tcdUsed" updated should be (tcdUsed - 2U) which indicates the number of TCDs can be loaded in the memory pool (because TCD[0] and TCD[1] have been loaded into the eDMA engine at this point already.).

For the last two continuous ISRs in a scatter/gather process, they both load the last TCD (The last ISR does not load a new TCD) from the memory pool to the eDMA engine when major loop completes. Therefore, ensure that the header and tcdUsed updated are identical for them. tcdUsed are both 0 in this case as no TCD to be loaded.

See the "eDMA basic data flow" in the eDMA Functional description section of the Reference Manual for further details.

param handle eDMA handle pointer.

Definition at line 1213 of file fsl_edma.c.

{
    assert(handle != NULL);
 
    /* Clear EDMA interrupt flag */
    handle->base->CINT = handle->channel;
    if ((handle->tcdPool == NULL) && (handle->callback != NULL))
    {
        (handle->callback)(handle, handle->userData, true, 0);
    }
    else /* Use the TCD queue. Please refer to the API descriptions in the eDMA header file for detailed information. */
    {
        uint32_t sga = handle->base->TCD[handle->channel].DLAST_SGA;
        uint32_t sga_index;
        int32_t tcds_done;
        uint8_t new_header;
        bool transfer_done;
 
        /* Check if transfer is already finished. */
        transfer_done = ((handle->base->TCD[handle->channel].CSR & DMA_CSR_DONE_MASK) != 0);
        /* Get the offset of the next transfer TCD blocks to be loaded into the eDMA engine. */
        sga -= (uint32_t)handle->tcdPool;
        /* Get the index of the next transfer TCD blocks to be loaded into the eDMA engine. */
        sga_index = sga / sizeof(edma_tcd_t);
        /* Adjust header positions. */
        if (transfer_done)
        {
            /* New header shall point to the next TCD to be loaded (current one is already finished) */
            new_header = sga_index;
        }
        else
        {
            /* New header shall point to this descriptor currently loaded (not finished yet) */
            new_header = sga_index ? sga_index - 1U : handle->tcdSize - 1U;
        }
        /* Calculate the number of finished TCDs */
        if (new_header == handle->header)
        {
            if (handle->tcdUsed == handle->tcdSize)
            {
                tcds_done = handle->tcdUsed;
            }
            else
            {
                /* No TCD in the memory are going to be loaded or internal error occurs. */
                tcds_done = 0;
            }
        }
        else
        {
            tcds_done = new_header - handle->header;
            if (tcds_done < 0)
            {
                tcds_done += handle->tcdSize;
            }
        }
        /* Advance header which points to the TCD to be loaded into the eDMA engine from memory. */
        handle->header = new_header;
        /* Release TCD blocks. tcdUsed is the TCD number which can be used/loaded in the memory pool. */
        handle->tcdUsed -= tcds_done;
        /* Invoke callback function. */
        if (handle->callback)
        {
            (handle->callback)(handle, handle->userData, transfer_done, tcds_done);
        }
 
        /* clear the DONE bit here is meaningful for below cases:
         *1.A new TCD has been loaded to EDMA already:
         * need to clear the DONE bit in the IRQ handler to avoid TCD in EDMA been overwritten
         * if peripheral request isn't coming before next transfer request.
         *2.A new TCD has not been loaded to EDMA:
         * for the case that transfer request occur in the privious edma callback, this is a case that doesn't
         * need scatter gather, so keep DONE bit during the next transfer request will re-install the TCD.
         */
        if (transfer_done)
        {
            handle->base->CDNE = handle->channel;
        }
    }
}

◆ EDMA_Init()

void EDMA_Init	(	DMA_Type *	base,
		const edma_config_t *	config
	)

Initializes the eDMA peripheral.

This function ungates the eDMA clock and configures the eDMA peripheral according to the configuration structure.

Parameters

base	eDMA peripheral base address.
config	A pointer to the configuration structure, see "edma_config_t".

Note: This function enables the minor loop map feature.

brief Initializes the eDMA peripheral.

This function ungates the eDMA clock and configures the eDMA peripheral according to the configuration structure.

param base eDMA peripheral base address. param config A pointer to the configuration structure, see "edma_config_t". note This function enables the minor loop map feature.

Definition at line 113 of file fsl_edma.c.

{
    assert(config != NULL);
 
    uint32_t tmpreg;
 
#if !(defined(FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL) && FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL)
    /* Ungate EDMA peripheral clock */
    CLOCK_EnableClock(s_edmaClockName[EDMA_GetInstance(base)]);
#endif /* FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL */
 
    /* clear all the enabled request, status to make sure EDMA status is in normal condition */
    base->ERQ = 0U;
    base->INT = 0xFFFFFFFFU;
    base->ERR = 0xFFFFFFFFU;
    /* Configure EDMA peripheral according to the configuration structure. */
    tmpreg = base->CR;
    tmpreg &= ~(DMA_CR_ERCA_MASK | DMA_CR_HOE_MASK | DMA_CR_CLM_MASK | DMA_CR_EDBG_MASK);
    tmpreg |= (DMA_CR_ERCA(config->enableRoundRobinArbitration) | DMA_CR_HOE(config->enableHaltOnError) |
               DMA_CR_CLM(config->enableContinuousLinkMode) | DMA_CR_EDBG(config->enableDebugMode) | DMA_CR_EMLM(true));
    base->CR = tmpreg;
}

Referenced by dmaInit().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ EDMA_InstallTCD()

void EDMA_InstallTCD	(	DMA_Type *	base,
		uint32_t	channel,
		edma_tcd_t *	tcd
	)

Push content of TCD structure into hardware TCD register.

Parameters

base	EDMA peripheral base address.
channel	EDMA channel number.
tcd	Point to TCD structure.

brief Push content of TCD structure into hardware TCD register.

param base EDMA peripheral base address. param channel EDMA channel number. param tcd Point to TCD structure.

Definition at line 81 of file fsl_edma.c.

{
    assert(channel < FSL_FEATURE_EDMA_MODULE_CHANNEL);
    assert(tcd != NULL);
    assert(((uint32_t)tcd & 0x1FU) == 0);
 
    /* Push tcd into hardware TCD register */
    base->TCD[channel].SADDR = tcd->SADDR;
    base->TCD[channel].SOFF = tcd->SOFF;
    base->TCD[channel].ATTR = tcd->ATTR;
    base->TCD[channel].NBYTES_MLNO = tcd->NBYTES;
    base->TCD[channel].SLAST = tcd->SLAST;
    base->TCD[channel].DADDR = tcd->DADDR;
    base->TCD[channel].DOFF = tcd->DOFF;
    base->TCD[channel].CITER_ELINKNO = tcd->CITER;
    base->TCD[channel].DLAST_SGA = tcd->DLAST_SGA;
    /* Clear DONE bit first, otherwise ESG cannot be set */
    base->TCD[channel].CSR = 0;
    base->TCD[channel].CSR = tcd->CSR;
    base->TCD[channel].BITER_ELINKNO = tcd->BITER;
}

Referenced by EDMA_SubmitTransfer().

Here is the caller graph for this function:

◆ EDMA_InstallTCDMemory()

void EDMA_InstallTCDMemory	(	edma_handle_t *	handle,
		edma_tcd_t *	tcdPool,
		uint32_t	tcdSize
	)

Installs the TCDs memory pool into the eDMA handle.

This function is called after the EDMA_CreateHandle to use scatter/gather feature. This function shall only be used while users need to use scatter gather mode. Scatter gather mode enables EDMA to load a new transfer control block (tcd) in hardware, and automatically reconfigure that DMA channel for a new transfer. Users need to prepare tcd memory and also configure tcds using interface EDMA_SubmitTransfer.

Parameters

handle	eDMA handle pointer.
tcdPool	A memory pool to store TCDs. It must be 32 bytes aligned.
tcdSize	The number of TCD slots.

brief Installs the TCDs memory pool into the eDMA handle.

This function is called after the EDMA_CreateHandle to use scatter/gather feature. This function shall only be used while users need to use scatter gather mode. Scatter gather mode enables EDMA to load a new transfer control block (tcd) in hardware, and automatically reconfigure that DMA channel for a new transfer. Users need to prepare tcd memory and also configure tcds using interface EDMA_SubmitTransfer.

param handle eDMA handle pointer. param tcdPool A memory pool to store TCDs. It must be 32 bytes aligned. param tcdSize The number of TCD slots.

Definition at line 812 of file fsl_edma.c.

{
    assert(handle != NULL);
    assert(((uint32_t)tcdPool & 0x1FU) == 0);
 
    /* Initialize tcd queue attribute. */
    handle->header = 0;
    handle->tail = 0;
    handle->tcdUsed = 0;
    handle->tcdSize = tcdSize;
    handle->flags = 0;
    handle->tcdPool = tcdPool;
}

◆ EDMA_PrepareTransfer()

void EDMA_PrepareTransfer	(	edma_transfer_config_t *	config,
		void *	srcAddr,
		uint32_t	srcWidth,
		void *	destAddr,
		uint32_t	destWidth,
		uint32_t	bytesEachRequest,
		uint32_t	transferBytes,
		edma_transfer_type_t	type
	)

Prepares the eDMA transfer structure.

This function prepares the transfer configuration structure according to the user input.

Parameters

config	The user configuration structure of type edma_transfer_t.
srcAddr	eDMA transfer source address.
srcWidth	eDMA transfer source address width(bytes).
destAddr	eDMA transfer destination address.
destWidth	eDMA transfer destination address width(bytes).
bytesEachRequest	eDMA transfer bytes per channel request.
transferBytes	eDMA transfer bytes to be transferred.
type	eDMA transfer type.

Note: The data address and the data width must be consistent. For example, if the SRC is 4 bytes, the source address must be 4 bytes aligned, or it results in source address error (SAE).

brief Prepares the eDMA transfer structure.

This function prepares the transfer configuration structure according to the user input.

param config The user configuration structure of type edma_transfer_t. param srcAddr eDMA transfer source address. param srcWidth eDMA transfer source address width(bytes). param destAddr eDMA transfer destination address. param destWidth eDMA transfer destination address width(bytes). param bytesEachRequest eDMA transfer bytes per channel request. param transferBytes eDMA transfer bytes to be transferred. param type eDMA transfer type. note The data address and the data width must be consistent. For example, if the SRC is 4 bytes, the source address must be 4 bytes aligned, or it results in source address error (SAE).

Definition at line 861 of file fsl_edma.c.

{
    assert(config != NULL);
    assert(srcAddr != NULL);
    assert(destAddr != NULL);
    assert((srcWidth == 1U) || (srcWidth == 2U) || (srcWidth == 4U) || (srcWidth == 16U) || (srcWidth == 32U));
    assert((destWidth == 1U) || (destWidth == 2U) || (destWidth == 4U) || (destWidth == 16U) || (destWidth == 32U));
    assert(transferBytes % bytesEachRequest == 0);
 
    /* Initializes the configure structure to zero. */
    memset(config, 0, sizeof(*config));
 
    config->destAddr = (uint32_t)destAddr;
    config->srcAddr = (uint32_t)srcAddr;
    config->minorLoopBytes = bytesEachRequest;
    config->majorLoopCounts = transferBytes / bytesEachRequest;
    switch (srcWidth)
    {
        case 1U:
            config->srcTransferSize = kEDMA_TransferSize1Bytes;
            break;
        case 2U:
            config->srcTransferSize = kEDMA_TransferSize2Bytes;
            break;
        case 4U:
            config->srcTransferSize = kEDMA_TransferSize4Bytes;
            break;
        case 16U:
            config->srcTransferSize = kEDMA_TransferSize16Bytes;
            break;
        case 32U:
            config->srcTransferSize = kEDMA_TransferSize32Bytes;
            break;
        default:
            break;
    }
    switch (destWidth)
    {
        case 1U:
            config->destTransferSize = kEDMA_TransferSize1Bytes;
            break;
        case 2U:
            config->destTransferSize = kEDMA_TransferSize2Bytes;
            break;
        case 4U:
            config->destTransferSize = kEDMA_TransferSize4Bytes;
            break;
        case 16U:
            config->destTransferSize = kEDMA_TransferSize16Bytes;
            break;
        case 32U:
            config->destTransferSize = kEDMA_TransferSize32Bytes;
            break;
        default:
            break;
    }
    switch (type)
    {
        case kEDMA_MemoryToMemory:
            config->destOffset = destWidth;
            config->srcOffset = srcWidth;
            break;
        case kEDMA_MemoryToPeripheral:
            config->destOffset = 0U;
            config->srcOffset = srcWidth;
            break;
        case kEDMA_PeripheralToMemory:
            config->destOffset = destWidth;
            config->srcOffset = 0U;
            break;
        default:
            break;
    }
}

Referenced by LPUART_ReceiveEDMA(), and LPUART_SendEDMA().

Here is the caller graph for this function:

◆ EDMA_ResetChannel()

void EDMA_ResetChannel	(	DMA_Type *	base,
		uint32_t	channel
	)

Sets all TCD registers to default values.

This function sets TCD registers for this channel to default values.

Parameters

base	eDMA peripheral base address.
channel	eDMA channel number.

Note: This function must not be called while the channel transfer is ongoing or it causes unpredictable results.; This function enables the auto stop request feature.

brief Sets all TCD registers to default values.

This function sets TCD registers for this channel to default values.

param base eDMA peripheral base address. param channel eDMA channel number. note This function must not be called while the channel transfer is ongoing or it causes unpredictable results. note This function enables the auto stop request feature.

Definition at line 189 of file fsl_edma.c.

{
    assert(channel < FSL_FEATURE_EDMA_MODULE_CHANNEL);
 
    EDMA_TcdReset((edma_tcd_t *)&base->TCD[channel]);
}

Referenced by LPSPI_MasterTransferEDMA(), and LPSPI_SlaveTransferEDMA().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ EDMA_SetBandWidth()

void EDMA_SetBandWidth	(	DMA_Type *	base,
		uint32_t	channel,
		edma_bandwidth_t	bandWidth
	)

Sets the bandwidth for the eDMA transfer.

Because the eDMA processes the minor loop, it continuously generates read/write sequences until the minor count is exhausted. The bandwidth forces the eDMA to stall after the completion of each read/write access to control the bus request bandwidth seen by the crossbar switch.

Parameters

base	eDMA peripheral base address.
channel	eDMA channel number.
bandWidth	A bandwidth setting, which can be one of the following: kEDMABandwidthStallNone kEDMABandwidthStall4Cycle kEDMABandwidthStall8Cycle brief Sets the bandwidth for the eDMA transfer.

Because the eDMA processes the minor loop, it continuously generates read/write sequences until the minor count is exhausted. The bandwidth forces the eDMA to stall after the completion of each read/write access to control the bus request bandwidth seen by the crossbar switch.

param base eDMA peripheral base address. param channel eDMA channel number. param bandWidth A bandwidth setting, which can be one of the following: arg kEDMABandwidthStallNone arg kEDMABandwidthStall4Cycle arg kEDMABandwidthStall8Cycle

Definition at line 293 of file fsl_edma.c.

{
    assert(channel < FSL_FEATURE_EDMA_MODULE_CHANNEL);
 
    base->TCD[channel].CSR = (base->TCD[channel].CSR & (~DMA_CSR_BWC_MASK)) | DMA_CSR_BWC(bandWidth);
}

◆ EDMA_SetCallback()

void EDMA_SetCallback	(	edma_handle_t *	handle,
		edma_callback	callback,
		void *	userData
	)

Installs a callback function for the eDMA transfer.

This callback is called in the eDMA IRQ handler. Use the callback to do something after the current major loop transfer completes. This function will be called every time one tcd finished transfer.

Parameters

handle	eDMA handle pointer.
callback	eDMA callback function pointer.
userData	A parameter for the callback function.

brief Installs a callback function for the eDMA transfer.

This callback is called in the eDMA IRQ handler. Use the callback to do something after the current major loop transfer completes. This function will be called every time one tcd finished transfer.

param handle eDMA handle pointer. param callback eDMA callback function pointer. param userData A parameter for the callback function.

Definition at line 836 of file fsl_edma.c.

{
    assert(handle != NULL);
 
    handle->callback = callback;
    handle->userData = userData;
}

Referenced by LPSPI_MasterTransferEDMA(), LPSPI_SlaveTransferEDMA(), and LPUART_TransferCreateHandleEDMA().

Here is the caller graph for this function:

◆ EDMA_SetChannelLink()

void EDMA_SetChannelLink	(	DMA_Type *	base,
		uint32_t	channel,
		edma_channel_link_type_t	type,
		uint32_t	linkedChannel
	)

Sets the channel link for the eDMA transfer.

This function configures either the minor link or the major link mode. The minor link means that the channel link is triggered every time CITER decreases by 1. The major link means that the channel link is triggered when the CITER is exhausted.

Parameters

base	eDMA peripheral base address.
channel	eDMA channel number.
type	A channel link type, which can be one of the following: kEDMA_LinkNone kEDMA_MinorLink kEDMA_MajorLink
linkedChannel	The linked channel number.

Note: Users should ensure that DONE flag is cleared before calling this interface, or the configuration is invalid.

brief Sets the channel link for the eDMA transfer.

This function configures either the minor link or the major link mode. The minor link means that the channel link is triggered every time CITER decreases by 1. The major link means that the channel link is triggered when the CITER is exhausted.

param base eDMA peripheral base address. param channel eDMA channel number. param type A channel link type, which can be one of the following: arg kEDMA_LinkNone arg kEDMA_MinorLink arg kEDMA_MajorLink param linkedChannel The linked channel number. note Users should ensure that DONE flag is cleared before calling this interface, or the configuration is invalid.

Definition at line 271 of file fsl_edma.c.

{
    assert(channel < FSL_FEATURE_EDMA_MODULE_CHANNEL);
    assert(linkedChannel < FSL_FEATURE_EDMA_MODULE_CHANNEL);
 
    EDMA_TcdSetChannelLink((edma_tcd_t *)&base->TCD[channel], type, linkedChannel);
}

Here is the call graph for this function:

◆ EDMA_SetChannelPreemptionConfig()

static void EDMA_SetChannelPreemptionConfig	(	DMA_Type *	base,
		uint32_t	channel,
		const edma_channel_Preemption_config_t *	config
	)

inlinestatic

Configures the eDMA channel preemption feature.

This function configures the channel preemption attribute and the priority of the channel.

Parameters

base	eDMA peripheral base address.
channel	eDMA channel number
config	A pointer to the channel preemption configuration structure.

Definition at line 388 of file fsl_edma.h.

{
    assert(channel < FSL_FEATURE_EDMA_MODULE_CHANNEL);
    assert(config != NULL);
 
    DMA_DCHPRIn(base, channel) =
        (DMA_DCHPRI0_DPA(!config->enablePreemptAbility) | DMA_DCHPRI0_ECP(config->enableChannelPreemption) |
         DMA_DCHPRI0_CHPRI(config->channelPriority));
}

◆ EDMA_SetMinorOffsetConfig()

void EDMA_SetMinorOffsetConfig	(	DMA_Type *	base,
		uint32_t	channel,
		const edma_minor_offset_config_t *	config
	)

Configures the eDMA minor offset feature.

The minor offset means that the signed-extended value is added to the source address or destination address after each minor loop.

Parameters

base	eDMA peripheral base address.
channel	eDMA channel number.
config	A pointer to the minor offset configuration structure.

brief Configures the eDMA minor offset feature.

The minor offset means that the signed-extended value is added to the source address or destination address after each minor loop.

param base eDMA peripheral base address. param channel eDMA channel number. param config A pointer to the minor offset configuration structure.

Definition at line 240 of file fsl_edma.c.

{
    assert(channel < FSL_FEATURE_EDMA_MODULE_CHANNEL);
    assert(config != NULL);
 
    uint32_t tmpreg;
 
    tmpreg = base->TCD[channel].NBYTES_MLOFFYES;
    tmpreg &= ~(DMA_NBYTES_MLOFFYES_SMLOE_MASK | DMA_NBYTES_MLOFFYES_DMLOE_MASK | DMA_NBYTES_MLOFFYES_MLOFF_MASK);
    tmpreg |=
        (DMA_NBYTES_MLOFFYES_SMLOE(config->enableSrcMinorOffset) |
         DMA_NBYTES_MLOFFYES_DMLOE(config->enableDestMinorOffset) | DMA_NBYTES_MLOFFYES_MLOFF(config->minorOffset));
    base->TCD[channel].NBYTES_MLOFFYES = tmpreg;
}

◆ EDMA_SetModulo()

void EDMA_SetModulo	(	DMA_Type *	base,
		uint32_t	channel,
		edma_modulo_t	srcModulo,
		edma_modulo_t	destModulo
	)

Sets the source modulo and the destination modulo for the eDMA transfer.

This function defines a specific address range specified to be the value after (SADDR + SOFF)/(DADDR + DOFF) calculation is performed or the original register value. It provides the ability to implement a circular data queue easily.

Parameters

base	eDMA peripheral base address.
channel	eDMA channel number.
srcModulo	A source modulo value.
destModulo	A destination modulo value.

brief Sets the source modulo and the destination modulo for the eDMA transfer.

This function defines a specific address range specified to be the value after (SADDR + SOFF)/(DADDR + DOFF) calculation is performed or the original register value. It provides the ability to implement a circular data queue easily.

param base eDMA peripheral base address. param channel eDMA channel number. param srcModulo A source modulo value. param destModulo A destination modulo value.

Definition at line 312 of file fsl_edma.c.

{
    assert(channel < FSL_FEATURE_EDMA_MODULE_CHANNEL);
 
    uint32_t tmpreg;
 
    tmpreg = base->TCD[channel].ATTR & (~(DMA_ATTR_SMOD_MASK | DMA_ATTR_DMOD_MASK));
    base->TCD[channel].ATTR = tmpreg | DMA_ATTR_DMOD(destModulo) | DMA_ATTR_SMOD(srcModulo);
}

◆ EDMA_SetTransferConfig()

void EDMA_SetTransferConfig	(	DMA_Type *	base,
		uint32_t	channel,
		const edma_transfer_config_t *	config,
		edma_tcd_t *	nextTcd
	)

Configures the eDMA transfer attribute.

This function configures the transfer attribute, including source address, destination address, transfer size, address offset, and so on. It also configures the scatter gather feature if the user supplies the TCD address. Example:

edma_transfer_t config;
edma_tcd_t tcd;
config.srcAddr = ..;
config.destAddr = ..;
...
EDMA_SetTransferConfig(DMA0, channel, &config, &stcd);

Parameters

base	eDMA peripheral base address.
channel	eDMA channel number.
config	Pointer to eDMA transfer configuration structure.
nextTcd	Point to TCD structure. It can be NULL if users do not want to enable scatter/gather feature.

Note: If nextTcd is not NULL, it means scatter gather feature is enabled and DREQ bit is cleared in the previous transfer configuration, which is set in the eDMA_ResetChannel.

brief Configures the eDMA transfer attribute.

This function configures the transfer attribute, including source address, destination address, transfer size, address offset, and so on. It also configures the scatter gather feature if the user supplies the TCD address. Example: code edma_transfer_t config; edma_tcd_t tcd; config.srcAddr = ..; config.destAddr = ..; ... EDMA_SetTransferConfig(DMA0, channel, &config, &stcd); endcode

param base eDMA peripheral base address. param channel eDMA channel number. param config Pointer to eDMA transfer configuration structure. param nextTcd Point to TCD structure. It can be NULL if users do not want to enable scatter/gather feature. note If nextTcd is not NULL, it means scatter gather feature is enabled and DREQ bit is cleared in the previous transfer configuration, which is set in the eDMA_ResetChannel.

Definition at line 221 of file fsl_edma.c.

{
    assert(channel < FSL_FEATURE_EDMA_MODULE_CHANNEL);
    assert(config != NULL);
    assert(((uint32_t)nextTcd & 0x1FU) == 0);
 
    EDMA_TcdSetTransferConfig((edma_tcd_t *)&base->TCD[channel], config, nextTcd);
}

Referenced by EDMA_SubmitTransfer(), LPSPI_MasterTransferEDMA(), and LPSPI_SlaveTransferEDMA().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ EDMA_StartTransfer()

void EDMA_StartTransfer ( edma_handle_t * handle )

eDMA starts transfer.

This function enables the channel request. Users can call this function after submitting the transfer request or before submitting the transfer request.

Parameters

handle eDMA handle pointer.

brief eDMA starts transfer.

This function enables the channel request. Users can call this function after submitting the transfer request or before submitting the transfer request.

param handle eDMA handle pointer.

Definition at line 1103 of file fsl_edma.c.

{
    assert(handle != NULL);
 
    if (handle->tcdPool == NULL)
    {
        handle->base->SERQ = DMA_SERQ_SERQ(handle->channel);
    }
    else /* Use the TCD queue. */
    {
        uint32_t primask;
        edma_tcd_t *tcdRegs = (edma_tcd_t *)&handle->base->TCD[handle->channel];
 
        handle->flags |= EDMA_TRANSFER_ENABLED_MASK;
 
        /* Check if there was at least one descriptor submitted since reset (TCD in registers is valid) */
        if (tcdRegs->DLAST_SGA != 0U)
        {
            primask = DisableGlobalIRQ();
            /* Check if channel request is actually disable. */
            if ((handle->base->ERQ & (1U << handle->channel)) == 0U)
            {
                /* Check if transfer is paused. */
                if ((!(tcdRegs->CSR & DMA_CSR_DONE_MASK)) || (tcdRegs->CSR & DMA_CSR_ESG_MASK))
                {
                    /*
                        Re-enable channel request must be as soon as possible, so must put it into
                        critical section to avoid task switching or interrupt service routine.
                    */
                    handle->base->SERQ = DMA_SERQ_SERQ(handle->channel);
                }
            }
            EnableGlobalIRQ(primask);
        }
    }
}

Referenced by LPSPI_MasterTransferEDMA(), LPSPI_SlaveTransferEDMA(), LPUART_ReceiveEDMA(), and LPUART_SendEDMA().

Here is the caller graph for this function:

◆ EDMA_StopTransfer()

void EDMA_StopTransfer ( edma_handle_t * handle )

eDMA stops transfer.

This function disables the channel request to pause the transfer. Users can call EDMA_StartTransfer() again to resume the transfer.

Parameters

handle eDMA handle pointer.

brief eDMA stops transfer.

This function disables the channel request to pause the transfer. Users can call EDMA_StartTransfer() again to resume the transfer.

param handle eDMA handle pointer.

Definition at line 1148 of file fsl_edma.c.

{
    assert(handle != NULL);
 
    handle->flags &= (~EDMA_TRANSFER_ENABLED_MASK);
    handle->base->CERQ = DMA_CERQ_CERQ(handle->channel);
}

◆ EDMA_SubmitTransfer()

status_t EDMA_SubmitTransfer	(	edma_handle_t *	handle,
		const edma_transfer_config_t *	config
	)

Submits the eDMA transfer request.

This function submits the eDMA transfer request according to the transfer configuration structure. In scatter gather mode, call this function will add a configured tcd to the circular list of tcd pool. The tcd pools is setup by call function EDMA_InstallTCDMemory before.

Parameters

handle	eDMA handle pointer.
config	Pointer to eDMA transfer configuration structure.

Return values

kStatus_EDMA_Success	It means submit transfer request succeed.
kStatus_EDMA_QueueFull	It means TCD queue is full. Submit transfer request is not allowed.
kStatus_EDMA_Busy	It means the given channel is busy, need to submit request later.

brief Submits the eDMA transfer request.

This function submits the eDMA transfer request according to the transfer configuration structure. In scatter gather mode, call this function will add a configured tcd to the circular list of tcd pool. The tcd pools is setup by call function EDMA_InstallTCDMemory before.

param handle eDMA handle pointer. param config Pointer to eDMA transfer configuration structure. retval kStatus_EDMA_Success It means submit transfer request succeed. retval kStatus_EDMA_QueueFull It means TCD queue is full. Submit transfer request is not allowed. retval kStatus_EDMA_Busy It means the given channel is busy, need to submit request later.

Definition at line 956 of file fsl_edma.c.

{
    assert(handle != NULL);
    assert(config != NULL);
 
    edma_tcd_t *tcdRegs = (edma_tcd_t *)&handle->base->TCD[handle->channel];
 
    if (handle->tcdPool == NULL)
    {
        /*
            Check if EDMA is busy: if the given channel started transfer, CSR will be not zero. Because
            if it is the last transfer, DREQ will be set. If not, ESG will be set. So in order to suit
            this check mechanism, EDMA_CreatHandle will clear CSR register.
        */
        if ((tcdRegs->CSR != 0) && ((tcdRegs->CSR & DMA_CSR_DONE_MASK) == 0))
        {
            return kStatus_EDMA_Busy;
        }
        else
        {
            EDMA_SetTransferConfig(handle->base, handle->channel, config, NULL);
            /* Enable auto disable request feature */
            handle->base->TCD[handle->channel].CSR |= DMA_CSR_DREQ_MASK;
            /* Enable major interrupt */
            handle->base->TCD[handle->channel].CSR |= DMA_CSR_INTMAJOR_MASK;
 
            return kStatus_Success;
        }
    }
    else /* Use the TCD queue. */
    {
        uint32_t primask;
        uint32_t csr;
        int8_t currentTcd;
        int8_t previousTcd;
        int8_t nextTcd;
 
        /* Check if tcd pool is full. */
        primask = DisableGlobalIRQ();
        if (handle->tcdUsed >= handle->tcdSize)
        {
            EnableGlobalIRQ(primask);
 
            return kStatus_EDMA_QueueFull;
        }
        currentTcd = handle->tail;
        handle->tcdUsed++;
        /* Calculate index of next TCD */
        nextTcd = currentTcd + 1U;
        if (nextTcd == handle->tcdSize)
        {
            nextTcd = 0U;
        }
        /* Advance queue tail index */
        handle->tail = nextTcd;
        EnableGlobalIRQ(primask);
        /* Calculate index of previous TCD */
        previousTcd = currentTcd ? currentTcd - 1U : handle->tcdSize - 1U;
        /* Configure current TCD block. */
        EDMA_TcdReset(&handle->tcdPool[currentTcd]);
        EDMA_TcdSetTransferConfig(&handle->tcdPool[currentTcd], config, NULL);
        /* Enable major interrupt */
        handle->tcdPool[currentTcd].CSR |= DMA_CSR_INTMAJOR_MASK;
        /* Link current TCD with next TCD for identification of current TCD */
        handle->tcdPool[currentTcd].DLAST_SGA = (uint32_t)&handle->tcdPool[nextTcd];
        /* Chain from previous descriptor unless tcd pool size is 1(this descriptor is its own predecessor). */
        if (currentTcd != previousTcd)
        {
            /* Enable scatter/gather feature in the previous TCD block. */
            csr = (handle->tcdPool[previousTcd].CSR | DMA_CSR_ESG_MASK) & ~DMA_CSR_DREQ_MASK;
            handle->tcdPool[previousTcd].CSR = csr;
            /*
                Check if the TCD block in the registers is the previous one (points to current TCD block). It
                is used to check if the previous TCD linked has been loaded in TCD register. If so, it need to
                link the TCD register in case link the current TCD with the dead chain when TCD loading occurs
                before link the previous TCD block.
            */
            if (tcdRegs->DLAST_SGA == (uint32_t)&handle->tcdPool[currentTcd])
            {
                /* Clear the DREQ bits for the dynamic scatter gather */
                tcdRegs->CSR |= DMA_CSR_DREQ_MASK;
                /* Enable scatter/gather also in the TCD registers. */
                csr = tcdRegs->CSR | DMA_CSR_ESG_MASK;
                /* Must write the CSR register one-time, because the transfer maybe finished anytime. */
                tcdRegs->CSR = csr;
                /*
                    It is very important to check the ESG bit!
                    Because this hardware design: if DONE bit is set, the ESG bit can not be set. So it can
                    be used to check if the dynamic TCD link operation is successful. If ESG bit is not set
                    and the DLAST_SGA is not the next TCD address(it means the dynamic TCD link succeed and
                    the current TCD block has been loaded into TCD registers), it means transfer finished
                    and TCD link operation fail, so must install TCD content into TCD registers and enable
                    transfer again. And if ESG is set, it means transfer has not finished, so TCD dynamic
                    link succeed.
                */
                if (tcdRegs->CSR & DMA_CSR_ESG_MASK)
                {
                    tcdRegs->CSR &= ~DMA_CSR_DREQ_MASK;
                    return kStatus_Success;
                }
                /*
                    Check whether the current TCD block is already loaded in the TCD registers. It is another
                    condition when ESG bit is not set: it means the dynamic TCD link succeed and the current
                    TCD block has been loaded into TCD registers.
                */
                if (tcdRegs->DLAST_SGA == (uint32_t)&handle->tcdPool[nextTcd])
                {
                    return kStatus_Success;
                }
                /*
                    If go to this, means the previous transfer finished, and the DONE bit is set.
                    So shall configure TCD registers.
                */
            }
            else if (tcdRegs->DLAST_SGA != 0)
            {
                /* The current TCD block has been linked successfully. */
                return kStatus_Success;
            }
            else
            {
                /*
                    DLAST_SGA is 0 and it means the first submit transfer, so shall configure
                    TCD registers.
                */
            }
        }
        /* There is no live chain, TCD block need to be installed in TCD registers. */
        EDMA_InstallTCD(handle->base, handle->channel, &handle->tcdPool[currentTcd]);
        /* Enable channel request again. */
        if (handle->flags & EDMA_TRANSFER_ENABLED_MASK)
        {
            handle->base->SERQ = DMA_SERQ_SERQ(handle->channel);
        }
 
        return kStatus_Success;
    }
}

Referenced by LPUART_ReceiveEDMA(), and LPUART_SendEDMA().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ EDMA_TcdDisableInterrupts()

void EDMA_TcdDisableInterrupts	(	edma_tcd_t *	tcd,
		uint32_t	mask
	)

Disables the interrupt source for the eDMA TCD.

Parameters

tcd	Point to the TCD structure.
mask	The mask of interrupt source to be set. Users need to use the defined edma_interrupt_enable_t type.

brief Disables the interrupt source for the eDMA TCD.

param tcd Point to the TCD structure. param mask The mask of interrupt source to be set. Users need to use the defined edma_interrupt_enable_t type.

Definition at line 610 of file fsl_edma.c.

{
    assert(tcd != NULL);
 
    /* Disable Major interrupt */
    if (mask & kEDMA_MajorInterruptEnable)
    {
        tcd->CSR &= ~DMA_CSR_INTMAJOR_MASK;
    }
 
    /* Disable Half major interrupt */
    if (mask & kEDMA_HalfInterruptEnable)
    {
        tcd->CSR &= ~DMA_CSR_INTHALF_MASK;
    }
}

◆ EDMA_TcdEnableAutoStopRequest()

static void EDMA_TcdEnableAutoStopRequest	(	edma_tcd_t *	tcd,
		bool	enable
	)

inlinestatic

Sets the auto stop request for the eDMA TCD.

If enabling the auto stop request, the eDMA hardware automatically disables the hardware channel request.

Parameters

tcd	A pointer to the TCD structure.
enable	The command to enable (true) or disable (false).

Definition at line 614 of file fsl_edma.h.

{
    assert(tcd != NULL);
    assert(((uint32_t)tcd & 0x1FU) == 0);
 
    tcd->CSR = (tcd->CSR & (~DMA_CSR_DREQ_MASK)) | DMA_CSR_DREQ(enable);
}

Here is the call graph for this function:

◆ EDMA_TcdEnableInterrupts()

void EDMA_TcdEnableInterrupts	(	edma_tcd_t *	tcd,
		uint32_t	mask
	)

Enables the interrupt source for the eDMA TCD.

Parameters

tcd	Point to the TCD structure.
mask	The mask of interrupt source to be set. Users need to use the defined edma_interrupt_enable_t type.

brief Enables the interrupt source for the eDMA TCD.

param tcd Point to the TCD structure. param mask The mask of interrupt source to be set. Users need to use the defined edma_interrupt_enable_t type.

Definition at line 586 of file fsl_edma.c.

{
    assert(tcd != NULL);
 
    /* Enable Major interrupt */
    if (mask & kEDMA_MajorInterruptEnable)
    {
        tcd->CSR |= DMA_CSR_INTMAJOR_MASK;
    }
 
    /* Enable Half major interrupt */
    if (mask & kEDMA_HalfInterruptEnable)
    {
        tcd->CSR |= DMA_CSR_INTHALF_MASK;
    }
}

◆ EDMA_TcdReset()

void EDMA_TcdReset ( edma_tcd_t * tcd )

Sets all fields to default values for the TCD structure.

This function sets all fields for this TCD structure to default value.

Parameters

tcd	Pointer to the TCD structure.

Note: This function enables the auto stop request feature.

brief Sets all fields to default values for the TCD structure.

This function sets all fields for this TCD structure to default value.

param tcd Pointer to the TCD structure. note This function enables the auto stop request feature.

Definition at line 392 of file fsl_edma.c.

{
    assert(tcd != NULL);
    assert(((uint32_t)tcd & 0x1FU) == 0);
 
    /* Reset channel TCD */
    tcd->SADDR = 0U;
    tcd->SOFF = 0U;
    tcd->ATTR = 0U;
    tcd->NBYTES = 0U;
    tcd->SLAST = 0U;
    tcd->DADDR = 0U;
    tcd->DOFF = 0U;
    tcd->CITER = 0U;
    tcd->DLAST_SGA = 0U;
    /* Enable auto disable request feature */
    tcd->CSR = DMA_CSR_DREQ(true);
    tcd->BITER = 0U;
}

Referenced by EDMA_ResetChannel(), EDMA_SubmitTransfer(), LPSPI_MasterTransferEDMA(), and LPSPI_SlaveTransferEDMA().

Here is the caller graph for this function:

◆ EDMA_TcdSetBandWidth()

static void EDMA_TcdSetBandWidth	(	edma_tcd_t *	tcd,
		edma_bandwidth_t	bandWidth
	)

inlinestatic

Sets the bandwidth for the eDMA TCD.

Because the eDMA processes the minor loop, it continuously generates read/write sequences until the minor count is exhausted. The bandwidth forces the eDMA to stall after the completion of each read/write access to control the bus request bandwidth seen by the crossbar switch.

Parameters

tcd	A pointer to the TCD structure.
bandWidth	A bandwidth setting, which can be one of the following: kEDMABandwidthStallNone kEDMABandwidthStall4Cycle kEDMABandwidthStall8Cycle

Definition at line 585 of file fsl_edma.h.

{
    assert(tcd != NULL);
    assert(((uint32_t)tcd & 0x1FU) == 0);
 
    tcd->CSR = (tcd->CSR & (~DMA_CSR_BWC_MASK)) | DMA_CSR_BWC(bandWidth);
}

◆ EDMA_TcdSetChannelLink()

void EDMA_TcdSetChannelLink	(	edma_tcd_t *	tcd,
		edma_channel_link_type_t	type,
		uint32_t	linkedChannel
	)

Sets the channel link for the eDMA TCD.

This function configures either a minor link or a major link. The minor link means the channel link is triggered every time CITER decreases by 1. The major link means that the channel link is triggered when the CITER is exhausted.

Note: Users should ensure that DONE flag is cleared before calling this interface, or the configuration is invalid.

Parameters

tcd	Point to the TCD structure.
type	Channel link type, it can be one of: kEDMA_LinkNone kEDMA_MinorLink kEDMA_MajorLink
linkedChannel	The linked channel number.

brief Sets the channel link for the eDMA TCD.

This function configures either a minor link or a major link. The minor link means the channel link is triggered every time CITER decreases by 1. The major link means that the channel link is triggered when the CITER is exhausted.

note Users should ensure that DONE flag is cleared before calling this interface, or the configuration is invalid. param tcd Point to the TCD structure. param type Channel link type, it can be one of: arg kEDMA_LinkNone arg kEDMA_MinorLink arg kEDMA_MajorLink param linkedChannel The linked channel number.

Definition at line 518 of file fsl_edma.c.

{
    assert(tcd != NULL);
    assert(((uint32_t)tcd & 0x1FU) == 0);
    assert(linkedChannel < FSL_FEATURE_EDMA_MODULE_CHANNEL);
 
    if (type == kEDMA_MinorLink) /* Minor link config */
    {
        uint32_t tmpreg;
 
        /* Enable minor link */
        tcd->CITER |= DMA_CITER_ELINKYES_ELINK_MASK;
        tcd->BITER |= DMA_BITER_ELINKYES_ELINK_MASK;
        /* Set linked channel */
        tmpreg = tcd->CITER & (~DMA_CITER_ELINKYES_LINKCH_MASK);
        tmpreg |= DMA_CITER_ELINKYES_LINKCH(linkedChannel);
        tcd->CITER = tmpreg;
        tmpreg = tcd->BITER & (~DMA_BITER_ELINKYES_LINKCH_MASK);
        tmpreg |= DMA_BITER_ELINKYES_LINKCH(linkedChannel);
        tcd->BITER = tmpreg;
    }
    else if (type == kEDMA_MajorLink) /* Major link config */
    {
        uint32_t tmpreg;
 
        /* Enable major link */
        tcd->CSR |= DMA_CSR_MAJORELINK_MASK;
        /* Set major linked channel */
        tmpreg = tcd->CSR & (~DMA_CSR_MAJORLINKCH_MASK);
        tcd->CSR = tmpreg | DMA_CSR_MAJORLINKCH(linkedChannel);
    }
    else /* Link none */
    {
        tcd->CITER &= ~DMA_CITER_ELINKYES_ELINK_MASK;
        tcd->BITER &= ~DMA_BITER_ELINKYES_ELINK_MASK;
        tcd->CSR &= ~DMA_CSR_MAJORELINK_MASK;
    }
}

Referenced by EDMA_SetChannelLink().

Here is the caller graph for this function:

◆ EDMA_TcdSetMinorOffsetConfig()

void EDMA_TcdSetMinorOffsetConfig	(	edma_tcd_t *	tcd,
		const edma_minor_offset_config_t *	config
	)

Configures the eDMA TCD minor offset feature.

A minor offset is a signed-extended value added to the source address or a destination address after each minor loop.

Parameters

tcd	A point to the TCD structure.
config	A pointer to the minor offset configuration structure.

brief Configures the eDMA TCD minor offset feature.

A minor offset is a signed-extended value added to the source address or a destination address after each minor loop.

param tcd A point to the TCD structure. param config A pointer to the minor offset configuration structure.

Definition at line 488 of file fsl_edma.c.

{
    assert(tcd != NULL);
    assert(((uint32_t)tcd & 0x1FU) == 0);
 
    uint32_t tmpreg;
 
    tmpreg = tcd->NBYTES &
             ~(DMA_NBYTES_MLOFFYES_SMLOE_MASK | DMA_NBYTES_MLOFFYES_DMLOE_MASK | DMA_NBYTES_MLOFFYES_MLOFF_MASK);
    tmpreg |=
        (DMA_NBYTES_MLOFFYES_SMLOE(config->enableSrcMinorOffset) |
         DMA_NBYTES_MLOFFYES_DMLOE(config->enableDestMinorOffset) | DMA_NBYTES_MLOFFYES_MLOFF(config->minorOffset));
    tcd->NBYTES = tmpreg;
}

◆ EDMA_TcdSetModulo()

void EDMA_TcdSetModulo	(	edma_tcd_t *	tcd,
		edma_modulo_t	srcModulo,
		edma_modulo_t	destModulo
	)

Sets the source modulo and the destination modulo for the eDMA TCD.

This function defines a specific address range specified to be the value after (SADDR + SOFF)/(DADDR + DOFF) calculation is performed or the original register value. It provides the ability to implement a circular data queue easily.

Parameters

tcd	A pointer to the TCD structure.
srcModulo	A source modulo value.
destModulo	A destination modulo value.

brief Sets the source modulo and the destination modulo for the eDMA TCD.

This function defines a specific address range specified to be the value after (SADDR + SOFF)/(DADDR + DOFF) calculation is performed or the original register value. It provides the ability to implement a circular data queue easily.

param tcd A pointer to the TCD structure. param srcModulo A source modulo value. param destModulo A destination modulo value.

Definition at line 568 of file fsl_edma.c.

{
    assert(tcd != NULL);
    assert(((uint32_t)tcd & 0x1FU) == 0);
 
    uint32_t tmpreg;
 
    tmpreg = tcd->ATTR & (~(DMA_ATTR_SMOD_MASK | DMA_ATTR_DMOD_MASK));
    tcd->ATTR = tmpreg | DMA_ATTR_DMOD(destModulo) | DMA_ATTR_SMOD(srcModulo);
}

◆ EDMA_TcdSetTransferConfig()

void EDMA_TcdSetTransferConfig	(	edma_tcd_t *	tcd,
		const edma_transfer_config_t *	config,
		edma_tcd_t *	nextTcd
	)

Configures the eDMA TCD transfer attribute.

The TCD is a transfer control descriptor. The content of the TCD is the same as the hardware TCD registers. The STCD is used in the scatter-gather mode. This function configures the TCD transfer attribute, including source address, destination address, transfer size, address offset, and so on. It also configures the scatter gather feature if the user supplies the next TCD address. Example:

edma_transfer_t config = {
...
}
edma_tcd_t tcd __aligned(32);
edma_tcd_t nextTcd __aligned(32);
EDMA_TcdSetTransferConfig(&tcd, &config, &nextTcd);

Parameters

tcd	Pointer to the TCD structure.
config	Pointer to eDMA transfer configuration structure.
nextTcd	Pointer to the next TCD structure. It can be NULL if users do not want to enable scatter/gather feature.

Note: TCD address should be 32 bytes aligned or it causes an eDMA error.; If the nextTcd is not NULL, the scatter gather feature is enabled and DREQ bit is cleared in the previous transfer configuration, which is set in the EDMA_TcdReset.

brief Configures the eDMA TCD transfer attribute.

The TCD is a transfer control descriptor. The content of the TCD is the same as the hardware TCD registers. The STCD is used in the scatter-gather mode. This function configures the TCD transfer attribute, including source address, destination address, transfer size, address offset, and so on. It also configures the scatter gather feature if the user supplies the next TCD address. Example: code edma_transfer_t config = { ... } edma_tcd_t tcd __aligned(32); edma_tcd_t nextTcd __aligned(32); EDMA_TcdSetTransferConfig(&tcd, &config, &nextTcd); endcode

param tcd Pointer to the TCD structure. param config Pointer to eDMA transfer configuration structure. param nextTcd Pointer to the next TCD structure. It can be NULL if users do not want to enable scatter/gather feature. note TCD address should be 32 bytes aligned or it causes an eDMA error. note If the nextTcd is not NULL, the scatter gather feature is enabled and DREQ bit is cleared in the previous transfer configuration, which is set in the EDMA_TcdReset.

Definition at line 439 of file fsl_edma.c.

{
    assert(tcd != NULL);
    assert(((uint32_t)tcd & 0x1FU) == 0);
    assert(config != NULL);
    assert(((uint32_t)nextTcd & 0x1FU) == 0);
 
    /* source address */
    tcd->SADDR = config->srcAddr;
    /* destination address */
    tcd->DADDR = config->destAddr;
    /* Source data and destination data transfer size */
    tcd->ATTR = DMA_ATTR_SSIZE(config->srcTransferSize) | DMA_ATTR_DSIZE(config->destTransferSize);
    /* Source address signed offset */
    tcd->SOFF = config->srcOffset;
    /* Destination address signed offset */
    tcd->DOFF = config->destOffset;
    /* Minor byte transfer count */
    tcd->NBYTES = config->minorLoopBytes;
    /* Current major iteration count */
    tcd->CITER = config->majorLoopCounts;
    /* Starting major iteration count */
    tcd->BITER = config->majorLoopCounts;
    /* Enable scatter/gather processing */
    if (nextTcd != NULL)
    {
        tcd->DLAST_SGA = (uint32_t)nextTcd;
        /*
            Before call EDMA_TcdSetTransferConfig or EDMA_SetTransferConfig,
            user must call EDMA_TcdReset or EDMA_ResetChannel which will set
            DREQ, so must use "|" or "&" rather than "=".
 
            Clear the DREQ bit because scatter gather has been enabled, so the
            previous transfer is not the last transfer, and channel request should
            be enabled at the next transfer(the next TCD).
        */
        tcd->CSR = (tcd->CSR | DMA_CSR_ESG_MASK) & ~DMA_CSR_DREQ_MASK;
    }
}

Referenced by EDMA_SetTransferConfig(), EDMA_SubmitTransfer(), LPSPI_MasterTransferEDMA(), and LPSPI_SlaveTransferEDMA().

Here is the caller graph for this function:

◆ EDMA_TriggerChannelStart()

static void EDMA_TriggerChannelStart	(	DMA_Type *	base,
		uint32_t	channel
	)

inlinestatic

Starts the eDMA transfer by using the software trigger.

This function starts a minor loop transfer.

Parameters

base	eDMA peripheral base address.
channel	eDMA channel number.

Definition at line 684 of file fsl_edma.h.

{
    assert(channel < FSL_FEATURE_DMAMUX_MODULE_CHANNEL);
 
    base->SSRT = DMA_SSRT_SSRT(channel);
}

Variable Documentation

◆ ATTR

__IO uint16_t _edma_tcd::ATTR

ATTR register, source/destination transfer size and modulo

Definition at line 210 of file fsl_edma.h.

Referenced by EDMA_CreateHandle(), EDMA_InstallTCD(), EDMA_TcdReset(), EDMA_TcdSetModulo(), and EDMA_TcdSetTransferConfig().

◆ base

DMA_Type* _edma_handle::base

eDMA peripheral base address.

Definition at line 249 of file fsl_edma.h.

Referenced by EDMA_AbortTransfer(), EDMA_CreateHandle(), EDMA_GetNextTCDAddress(), EDMA_HandleIRQ(), EDMA_StartTransfer(), EDMA_StopTransfer(), EDMA_SubmitTransfer(), LPSPI_MasterTransferEDMA(), LPSPI_MasterTransferGetCountEDMA(), LPSPI_SlaveTransferEDMA(), LPSPI_SlaveTransferGetCountEDMA(), LPUART_TransferGetReceiveCountEDMA(), and LPUART_TransferGetSendCountEDMA().

◆ BITER

__IO uint16_t _edma_tcd::BITER

BITER register, begin minor loop count.

Definition at line 218 of file fsl_edma.h.

Referenced by EDMA_CreateHandle(), EDMA_InstallTCD(), EDMA_TcdReset(), EDMA_TcdSetChannelLink(), and EDMA_TcdSetTransferConfig().

◆ callback

edma_callback _edma_handle::callback

Callback function for major count exhausted.

Definition at line 247 of file fsl_edma.h.

Referenced by EDMA_HandleIRQ(), and EDMA_SetCallback().

◆ channel

uint8_t _edma_handle::channel

eDMA channel number.

Definition at line 251 of file fsl_edma.h.

Referenced by EDMA_AbortTransfer(), EDMA_CreateHandle(), EDMA_GetNextTCDAddress(), EDMA_HandleIRQ(), EDMA_StartTransfer(), EDMA_StopTransfer(), EDMA_SubmitTransfer(), LPSPI_MasterTransferEDMA(), LPSPI_MasterTransferGetCountEDMA(), LPSPI_SlaveTransferEDMA(), LPSPI_SlaveTransferGetCountEDMA(), LPUART_TransferGetReceiveCountEDMA(), and LPUART_TransferGetSendCountEDMA().

◆ channelPriority

uint8_t _edma_channel_Preemption_config::channelPriority

Channel priority

Definition at line 189 of file fsl_edma.h.

◆ CITER

__IO uint16_t _edma_tcd::CITER

CITER register, current minor loop numbers, for unfinished minor loop.

Definition at line 215 of file fsl_edma.h.

Referenced by EDMA_CreateHandle(), EDMA_InstallTCD(), EDMA_TcdReset(), EDMA_TcdSetChannelLink(), and EDMA_TcdSetTransferConfig().

◆ CSR

__IO uint16_t _edma_tcd::CSR

CSR register, for TCD control status

Definition at line 217 of file fsl_edma.h.

Referenced by EDMA_CreateHandle(), EDMA_InstallTCD(), EDMA_StartTransfer(), EDMA_SubmitTransfer(), EDMA_TcdDisableInterrupts(), EDMA_TcdEnableAutoStopRequest(), EDMA_TcdEnableInterrupts(), EDMA_TcdReset(), EDMA_TcdSetBandWidth(), EDMA_TcdSetChannelLink(), and EDMA_TcdSetTransferConfig().

◆ DADDR

__IO uint32_t _edma_tcd::DADDR

DADDR register, used for destination address

Definition at line 213 of file fsl_edma.h.

Referenced by EDMA_CreateHandle(), EDMA_InstallTCD(), EDMA_TcdReset(), and EDMA_TcdSetTransferConfig().

◆ destAddr

uint32_t _edma_transfer_config::destAddr

Destination data address.

Definition at line 173 of file fsl_edma.h.

Referenced by LPSPI_MasterTransferEDMA(), and LPSPI_SlaveTransferEDMA().

◆ destOffset

int16_t _edma_transfer_config::destOffset

Sign-extended offset applied to the current destination address to form the next-state value as each destination write is completed.

Definition at line 178 of file fsl_edma.h.

Referenced by LPSPI_MasterTransferEDMA(), and LPSPI_SlaveTransferEDMA().

◆ destTransferSize

edma_transfer_size_t _edma_transfer_config::destTransferSize

Destination data transfer size.

Definition at line 175 of file fsl_edma.h.

Referenced by LPSPI_MasterTransferEDMA(), and LPSPI_SlaveTransferEDMA().

◆ DLAST_SGA

__IO uint32_t _edma_tcd::DLAST_SGA

DLASTSGA register, next tcd address used in scatter-gather mode

Definition at line 216 of file fsl_edma.h.

Referenced by EDMA_CreateHandle(), EDMA_InstallTCD(), EDMA_StartTransfer(), EDMA_SubmitTransfer(), EDMA_TcdReset(), and EDMA_TcdSetTransferConfig().

◆ DOFF

__IO uint16_t _edma_tcd::DOFF

DOFF register, used for destination offset

Definition at line 214 of file fsl_edma.h.

Referenced by EDMA_CreateHandle(), EDMA_InstallTCD(), EDMA_TcdReset(), and EDMA_TcdSetTransferConfig().

◆ enableChannelPreemption

bool _edma_channel_Preemption_config::enableChannelPreemption

If true: a channel can be suspended by other channel with higher priority

Definition at line 187 of file fsl_edma.h.

◆ enableContinuousLinkMode

bool _edma_config::enableContinuousLinkMode

Enable (true) continuous link mode. Upon minor loop completion, the channel activates again if that channel has a minor loop channel link enabled and the link channel is itself.

Definition at line 154 of file fsl_edma.h.

◆ enableDebugMode

bool _edma_config::enableDebugMode

Enable(true) eDMA debug mode. When in debug mode, the eDMA stalls the start of a new channel. Executing channels are allowed to complete.

Definition at line 161 of file fsl_edma.h.

◆ enableDestMinorOffset

bool _edma_minor_offset_config::enableDestMinorOffset

Enable(true) or Disable(false) destination minor loop offset.

Definition at line 196 of file fsl_edma.h.

◆ enableHaltOnError

bool _edma_config::enableHaltOnError

Enable (true) transfer halt on error. Any error causes the HALT bit to set. Subsequently, all service requests are ignored until the HALT bit is cleared.

Definition at line 157 of file fsl_edma.h.

Referenced by dmaInit().

◆ enablePreemptAbility

bool _edma_channel_Preemption_config::enablePreemptAbility

If true: a channel can suspend other channel with low priority

Definition at line 188 of file fsl_edma.h.

◆ enableRoundRobinArbitration

bool _edma_config::enableRoundRobinArbitration

Enable (true) round robin channel arbitration method or fixed priority arbitration is used for channel selection

Definition at line 159 of file fsl_edma.h.

◆ enableSrcMinorOffset

bool _edma_minor_offset_config::enableSrcMinorOffset

Enable(true) or Disable(false) source minor loop offset.

Definition at line 195 of file fsl_edma.h.

◆ flags

uint8_t _edma_handle::flags

The status of the current channel.

Definition at line 257 of file fsl_edma.h.

Referenced by EDMA_InstallTCDMemory(), EDMA_StartTransfer(), EDMA_StopTransfer(), and EDMA_SubmitTransfer().

◆ header

volatile int8_t _edma_handle::header

The first TCD index. Should point to the next TCD to be loaded into the eDMA engine.

Definition at line 252 of file fsl_edma.h.

Referenced by EDMA_AbortTransfer(), EDMA_HandleIRQ(), and EDMA_InstallTCDMemory().

◆ majorLoopCounts

uint32_t _edma_transfer_config::majorLoopCounts

Major loop iteration count.

Definition at line 181 of file fsl_edma.h.

Referenced by LPSPI_MasterTransferEDMA(), and LPSPI_SlaveTransferEDMA().

◆ minorLoopBytes

uint32_t _edma_transfer_config::minorLoopBytes

Bytes to transfer in a minor loop

Definition at line 180 of file fsl_edma.h.

Referenced by LPSPI_MasterTransferEDMA(), and LPSPI_SlaveTransferEDMA().

◆ minorOffset

uint32_t _edma_minor_offset_config::minorOffset

Offset for a minor loop mapping.

Definition at line 197 of file fsl_edma.h.

◆ NBYTES

__IO uint32_t _edma_tcd::NBYTES

Nbytes register, minor loop length in bytes

Definition at line 211 of file fsl_edma.h.

Referenced by EDMA_CreateHandle(), EDMA_InstallTCD(), EDMA_TcdReset(), EDMA_TcdSetMinorOffsetConfig(), and EDMA_TcdSetTransferConfig().

◆ SADDR

__IO uint32_t _edma_tcd::SADDR

SADDR register, used to save source address

Definition at line 208 of file fsl_edma.h.

Referenced by EDMA_CreateHandle(), EDMA_InstallTCD(), EDMA_TcdReset(), and EDMA_TcdSetTransferConfig().

◆ SLAST

__IO uint32_t _edma_tcd::SLAST

SLAST register

Definition at line 212 of file fsl_edma.h.

Referenced by EDMA_CreateHandle(), EDMA_InstallTCD(), and EDMA_TcdReset().

◆ SOFF

__IO uint16_t _edma_tcd::SOFF

SOFF register, save offset bytes every transfer

Definition at line 209 of file fsl_edma.h.

Referenced by EDMA_CreateHandle(), EDMA_InstallTCD(), EDMA_TcdReset(), and EDMA_TcdSetTransferConfig().

◆ srcAddr

uint32_t _edma_transfer_config::srcAddr

Source data address.

Definition at line 172 of file fsl_edma.h.

Referenced by LPSPI_MasterTransferEDMA(), and LPSPI_SlaveTransferEDMA().

◆ srcOffset

int16_t _edma_transfer_config::srcOffset

Sign-extended offset applied to the current source address to form the next-state value as each source read is completed.

Definition at line 176 of file fsl_edma.h.

Referenced by LPSPI_MasterTransferEDMA(), and LPSPI_SlaveTransferEDMA().

◆ srcTransferSize

edma_transfer_size_t _edma_transfer_config::srcTransferSize

Source data transfer size.

Definition at line 174 of file fsl_edma.h.

Referenced by LPSPI_MasterTransferEDMA(), and LPSPI_SlaveTransferEDMA().

◆ tail

volatile int8_t _edma_handle::tail

The last TCD index. Should point to the next TCD to be stored into the memory pool.

Definition at line 253 of file fsl_edma.h.

Referenced by EDMA_AbortTransfer(), EDMA_InstallTCDMemory(), and EDMA_SubmitTransfer().

◆ tcdPool

edma_tcd_t* _edma_handle::tcdPool

Pointer to memory stored TCDs.

Definition at line 250 of file fsl_edma.h.

Referenced by EDMA_AbortTransfer(), EDMA_HandleIRQ(), EDMA_InstallTCDMemory(), EDMA_StartTransfer(), and EDMA_SubmitTransfer().

◆ tcdSize

volatile int8_t _edma_handle::tcdSize

The total number of TCD slots in the queue.

Definition at line 256 of file fsl_edma.h.

Referenced by EDMA_GetUnusedTCDNumber(), EDMA_HandleIRQ(), EDMA_InstallTCDMemory(), and EDMA_SubmitTransfer().

◆ tcdUsed

volatile int8_t _edma_handle::tcdUsed

The number of used TCD slots. Should reflect the number of TCDs can be used/loaded in the memory.

Definition at line 254 of file fsl_edma.h.

Referenced by EDMA_AbortTransfer(), EDMA_GetUnusedTCDNumber(), EDMA_HandleIRQ(), EDMA_InstallTCDMemory(), and EDMA_SubmitTransfer().

◆ userData

void* _edma_handle::userData

Callback function parameter.

Definition at line 248 of file fsl_edma.h.

Referenced by EDMA_HandleIRQ(), and EDMA_SetCallback().

Data Structures

Variables

Driver version

eDMA initialization and de-initialization

eDMA Channel Operation

eDMA TCD Operation

eDMA Channel Transfer Operation

eDMA Channel Status Operation

eDMA Transactional Operation

Detailed Description

Typedef Documentation

◆ edma_bandwidth_t

◆ edma_callback

◆ edma_channel_link_type_t

◆ edma_channel_Preemption_config_t

◆ edma_config_t

◆ edma_handle_t

◆ edma_interrupt_enable_t

◆ edma_minor_offset_config_t

◆ edma_modulo_t

◆ edma_tcd_t

◆ edma_transfer_config_t

◆ edma_transfer_size_t

◆ edma_transfer_type_t

Enumeration Type Documentation

◆ _edma_bandwidth

◆ _edma_channel_link_type

◆ _edma_channel_status_flags

◆ _edma_error_status_flags

◆ _edma_interrupt_enable

◆ _edma_modulo

◆ _edma_transfer_size

◆ _edma_transfer_status

◆ _edma_transfer_type

Function Documentation

◆ EDMA_AbortTransfer()

◆ EDMA_ClearChannelStatusFlags()

◆ EDMA_CreateHandle()

◆ EDMA_Deinit()

◆ EDMA_DisableChannelInterrupts()

◆ EDMA_DisableChannelRequest()

◆ EDMA_EnableAsyncRequest()

◆ EDMA_EnableAutoStopRequest()

◆ EDMA_EnableChannelInterrupts()

◆ EDMA_EnableChannelRequest()

◆ EDMA_GetChannelStatusFlags()

◆ EDMA_GetDefaultConfig()

◆ EDMA_GetErrorStatusFlags()

◆ EDMA_GetNextTCDAddress()

◆ EDMA_GetRemainingMajorLoopCount()

◆ EDMA_GetUnusedTCDNumber()

◆ EDMA_HandleIRQ()

◆ EDMA_Init()

◆ EDMA_InstallTCD()

◆ EDMA_InstallTCDMemory()

◆ EDMA_PrepareTransfer()

◆ EDMA_ResetChannel()

◆ EDMA_SetBandWidth()

◆ EDMA_SetCallback()

◆ EDMA_SetChannelLink()

◆ EDMA_SetChannelPreemptionConfig()

◆ EDMA_SetMinorOffsetConfig()

◆ EDMA_SetModulo()

◆ EDMA_SetTransferConfig()

◆ EDMA_StartTransfer()

◆ EDMA_StopTransfer()

◆ EDMA_SubmitTransfer()

◆ EDMA_TcdDisableInterrupts()

◆ EDMA_TcdEnableAutoStopRequest()

◆ EDMA_TcdEnableInterrupts()

◆ EDMA_TcdReset()

◆ EDMA_TcdSetBandWidth()

◆ EDMA_TcdSetChannelLink()

◆ EDMA_TcdSetMinorOffsetConfig()

◆ EDMA_TcdSetModulo()

◆ EDMA_TcdSetTransferConfig()

◆ EDMA_TriggerChannelStart()

Variable Documentation

◆ ATTR

◆ base