Overview

The MCUXpresso SDK provides a peripheral driver for the enhanced Direct Memory Access (eDMA) of MCUXpresso SDK devices.

Typical use case

eDMA Operation

edma_transfer_config_t transferConfig;
edma_config_t userConfig;
uint32_t transferDone = false;
EDMA_GetDefaultConfig(&userConfig);
EDMA_Init(DMA0, &userConfig);
EDMA_CreateHandle(&g_EDMA_Handle, DMA0, channel);
EDMA_SetCallback(&g_EDMA_Handle, EDMA_Callback, &transferDone);
EDMA_PrepareTransfer(&transferConfig, srcAddr, srcWidth, destAddr, destWidth,
                     bytesEachRequest, transferBytes, kEDMA_MemoryToMemory);
EDMA_SubmitTransfer(&g_EDMA_Handle, &transferConfig, true);
EDMA_StartTransfer(&g_EDMA_Handle);
/* Waits for the eDMA transfer to finish */
while (transferDone != true);

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

struct	edma_transfer_config_t
	eDMA transfer configuration More...

struct	edma_channel_Preemption_config_t
	eDMA channel priority configuration More...

struct	edma_minor_offset_config_t
	eDMA minor offset configuration More...

struct	edma_tcd_t
	eDMA TCD. More...

struct	edma_handle_t
	eDMA transfer handle structure More...

Macros
#define	DMA_DCHPRI_INDEX(channel) (((channel) & ~0x03U) \| (3 - ((channel)&0x03U)))
	Compute the offset unit from DCHPRI3.

#define	DMA_DCHPRIn(base, channel) ((volatile uint8_t *)&(base->DCHPRI3))[DMA_DCHPRI_INDEX(channel)]
	Get the pointer of DCHPRIn.

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

Enumerations
enum	edma_transfer_size_t { kEDMA_TransferSize1Bytes = 0x0U, kEDMA_TransferSize2Bytes = 0x1U, kEDMA_TransferSize4Bytes = 0x2U, kEDMA_TransferSize16Bytes = 0x4U, kEDMA_TransferSize32Bytes = 0x5U }
	eDMA transfer configuration More...

enum	edma_modulo_t { 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_t { kEDMA_BandwidthStallNone = 0x0U, kEDMA_BandwidthStall4Cycle = 0x2U, kEDMA_BandwidthStall8Cycle = 0x3U }
	Bandwidth control. More...

enum	edma_channel_link_type_t { 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_ValidFlag = DMA_ES_VLD_MASK }
	eDMA channel error status flags. More...

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

enum	edma_transfer_type_t { 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...

Driver version
#define	FSL_EDMA_DRIVER_VERSION (MAKE_VERSION(2, 1, 1))
	eDMA driver version More...

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

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

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

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

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

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

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

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. More...

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

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. More...

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

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

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

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

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

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

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

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

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

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. More...

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

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

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

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

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

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

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. More...

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

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

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

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

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

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

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. More...

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

void	EDMA_StartTransfer (edma_handle_t *handle)
	eDMA starts transfer. More...

void	EDMA_StopTransfer (edma_handle_t *handle)
	eDMA stops transfer. More...

void	EDMA_AbortTransfer (edma_handle_t *handle)
	eDMA aborts transfer. More...

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

Data Structure Documentation

struct edma_config_t

Data Fields
bool	enableContinuousLinkMode
	Enable (true) continuous link mode. More...

bool	enableHaltOnError
	Enable (true) transfer halt on error. More...

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

bool	enableDebugMode
	Enable(true) eDMA debug mode. More...

Field Documentation

bool edma_config_t::enableContinuousLinkMode

Upon minor loop completion, the channel activates again if that channel has a minor loop channel link enabled and the link channel is itself.

bool edma_config_t::enableHaltOnError

Any error causes the HALT bit to set. Subsequently, all service requests are ignored until the HALT bit is cleared.

bool edma_config_t::enableDebugMode

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

struct edma_transfer_config_t

This structure configures the source/destination transfer attribute. This figure shows the eDMA's transfer model:

| | | |_______________| Major Loop Count 2 | | | | |_______________|____________________|–> Minor loop Complete

------------------------------------------------------—> Transfer complete

Data Fields
uint32_t	srcAddr
	Source data address. More...

uint32_t	destAddr
	Destination data address. More...

edma_transfer_size_t	srcTransferSize
	Source data transfer size. More...

edma_transfer_size_t	destTransferSize
	Destination data transfer size. More...

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

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

uint32_t	minorLoopBytes
	Bytes to transfer in a minor loop.

uint32_t	majorLoopCounts
	Major loop iteration count. More...

Field Documentation

uint32_t edma_transfer_config_t::srcAddr

uint32_t edma_transfer_config_t::destAddr

edma_transfer_size_t edma_transfer_config_t::srcTransferSize

edma_transfer_size_t edma_transfer_config_t::destTransferSize

int16_t edma_transfer_config_t::srcOffset

int16_t edma_transfer_config_t::destOffset

uint32_t edma_transfer_config_t::majorLoopCounts

struct edma_channel_Preemption_config_t

Data Fields
bool	enableChannelPreemption
	If true: a channel can be suspended by other channel with higher priority.

bool	enablePreemptAbility
	If true: a channel can suspend other channel with low priority.

uint8_t	channelPriority
	Channel priority.

struct edma_minor_offset_config_t

Data Fields
bool	enableSrcMinorOffset
	Enable(true) or Disable(false) source minor loop offset. More...

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

uint32_t	minorOffset
	Offset for a minor loop mapping. More...

Field Documentation

bool edma_minor_offset_config_t::enableSrcMinorOffset

bool edma_minor_offset_config_t::enableDestMinorOffset

uint32_t edma_minor_offset_config_t::minorOffset

struct edma_tcd_t

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.

Data Fields
__IO uint32_t	SADDR
	SADDR register, used to save source address.

__IO uint16_t	SOFF
	SOFF register, save offset bytes every transfer.

__IO uint16_t	ATTR
	ATTR register, source/destination transfer size and modulo.

__IO uint32_t	NBYTES
	Nbytes register, minor loop length in bytes.

__IO uint32_t	SLAST
	SLAST register.

__IO uint32_t	DADDR
	DADDR register, used for destination address.

__IO uint16_t	DOFF
	DOFF register, used for destination offset.

__IO uint16_t	CITER
	CITER register, current minor loop numbers, for unfinished minor loop. More...

__IO uint32_t	DLAST_SGA
	DLASTSGA register, next stcd address used in scatter-gather mode.

__IO uint16_t	CSR
	CSR register, for TCD control status.

__IO uint16_t	BITER
	BITER register, begin minor loop count. More...

Field Documentation

__IO uint16_t edma_tcd_t::CITER

__IO uint16_t edma_tcd_t::BITER

struct edma_handle_t

Data Fields
edma_callback	callback
	Callback function for major count exhausted. More...

void *	userData
	Callback function parameter. More...

DMA_Type *	base
	eDMA peripheral base address. More...

edma_tcd_t *	tcdPool
	Pointer to memory stored TCDs. More...

uint8_t	channel
	eDMA channel number. More...

volatile int8_t	header
	The first TCD index. More...

volatile int8_t	tail
	The last TCD index. More...

volatile int8_t	tcdUsed
	The number of used TCD slots. More...

volatile int8_t	tcdSize
	The total number of TCD slots in the queue. More...

uint8_t	flags
	The status of the current channel. More...

Field Documentation

edma_callback edma_handle_t::callback

void* edma_handle_t::userData

DMA_Type* edma_handle_t::base

edma_tcd_t* edma_handle_t::tcdPool

uint8_t edma_handle_t::channel

volatile int8_t edma_handle_t::header

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

volatile int8_t edma_handle_t::tail

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

volatile int8_t edma_handle_t::tcdUsed

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

volatile int8_t edma_handle_t::tcdSize

uint8_t edma_handle_t::flags

Macro Definition Documentation

#define FSL_EDMA_DRIVER_VERSION (MAKE_VERSION(2, 1, 1))

Version 2.1.1.

Typedef Documentation

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

Enumeration Type Documentation

enum edma_transfer_size_t

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_TransferSize16Bytes	Source/Destination data transfer size is 16 bytes every time.
kEDMA_TransferSize32Bytes	Source/Destination data transfer size is 32 bytes every time.

enum edma_modulo_t

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.

enum edma_bandwidth_t

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.

enum edma_channel_link_type_t

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

enum _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

enum _edma_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_ValidFlag	No error occurred, this bit is 0. Otherwise, it is 1.

enum edma_interrupt_enable_t

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.

enum edma_transfer_type_t

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

enum _edma_transfer_status

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

Function Documentation

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

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.

void EDMA_Deinit ( DMA_Type * base )

This function gates the eDMA clock.

Parameters

base	eDMA peripheral base address.

void EDMA_GetDefaultConfig ( edma_config_t * config )

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.

void EDMA_ResetChannel	(	DMA_Type *	base,
		uint32_t	channel
	)

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.

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

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.

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

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.

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

inlinestatic

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.

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

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.

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

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

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

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.

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

inlinestatic

Parameters

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

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

inlinestatic

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).

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

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.

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

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.

void EDMA_TcdReset ( edma_tcd_t * tcd )

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.

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

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.

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

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.

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

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.

static void EDMA_TcdSetBandWidth	(	edma_tcd_t *	tcd,
		edma_bandwidth_t	bandWidth
	)

inlinestatic

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

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

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.

static void EDMA_TcdEnableAutoStopRequest	(	edma_tcd_t *	tcd,
		bool	enable
	)

inlinestatic

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).

void EDMA_TcdEnableInterrupts	(	edma_tcd_t *	tcd,
		uint32_t	mask
	)

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.

void EDMA_TcdDisableInterrupts	(	edma_tcd_t *	tcd,
		uint32_t	mask
	)

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.

static void EDMA_EnableChannelRequest	(	DMA_Type *	base,
		uint32_t	channel
	)

inlinestatic

This function enables the hardware channel request.

Parameters

base	eDMA peripheral base address.
channel	eDMA channel number.

static void EDMA_DisableChannelRequest	(	DMA_Type *	base,
		uint32_t	channel
	)

inlinestatic

This function disables the hardware channel request.

Parameters

base	eDMA peripheral base address.
channel	eDMA channel number.

static void EDMA_TriggerChannelStart	(	DMA_Type *	base,
		uint32_t	channel
	)

inlinestatic

This function starts a minor loop transfer.

Parameters

base	eDMA peripheral base address.
channel	eDMA channel number.

uint32_t EDMA_GetRemainingMajorLoopCount	(	DMA_Type *	base,
		uint32_t	channel
	)

This function checks the TCD (Task Control Descriptor) status for a specified eDMA channel and returns the 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)

static uint32_t EDMA_GetErrorStatusFlags ( DMA_Type * base )

inlinestatic

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.

uint32_t EDMA_GetChannelStatusFlags	(	DMA_Type *	base,
		uint32_t	channel
	)

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.

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

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.

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

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.

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

This function is called after the EDMA_CreateHandle to use scatter/gather feature.

Parameters

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

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

This callback is called in the eDMA IRQ handler. Use the callback to do something after the current major loop transfer completes.

Parameters

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

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
	)

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).

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

This function submits the eDMA transfer request according to the transfer configuration structure. If submitting the transfer request repeatedly, this function packs an unprocessed request as a TCD and enables scatter/gather feature to process it in the next time.

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.

void EDMA_StartTransfer ( edma_handle_t * handle )

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.

void EDMA_StopTransfer ( edma_handle_t * handle )

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.

void EDMA_AbortTransfer ( edma_handle_t * handle )

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.

void EDMA_HandleIRQ ( edma_handle_t * handle )

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.

Overview

Typical use case

eDMA Operation

Data Structures

Macros

Typedefs

Enumerations

Driver version

eDMA initialization and de-initialization

eDMA Channel Operation

eDMA TCD Operation

eDMA Channel Transfer Operation

eDMA Channel Status Operation

eDMA Transactional Operation

Data Structure Documentation

Data Fields

Field Documentation

Data Fields

Field Documentation

Data Fields

Data Fields

Field Documentation

Data Fields

Field Documentation

Data Fields

Field Documentation

Macro Definition Documentation

Typedef Documentation

Enumeration Type Documentation

Function Documentation