Data Structures
struct	tDMAControlTable

Macros
#define	uDMATaskStructEntry(ui32TransferCount, ui32ItemSize, ui32SrcIncrement, pvSrcAddr, ui32DstIncrement, pvDstAddr, ui32ArbSize, ui32Mode)

Functions
void	uDMAEnable (void)

void	uDMADisable (void)

uint32_t	uDMAErrorStatusGet (void)

void	uDMAErrorStatusClear (void)

void	uDMAChannelEnable (uint32_t ui32ChannelNum)

void	uDMAChannelDisable (uint32_t ui32ChannelNum)

bool	uDMAChannelIsEnabled (uint32_t ui32ChannelNum)

void	uDMAControlBaseSet (void *psControlTable)

void *	uDMAControlBaseGet (void)

void *	uDMAControlAlternateBaseGet (void)

void	uDMAChannelRequest (uint32_t ui32ChannelNum)

void	uDMAChannelAttributeEnable (uint32_t ui32ChannelNum, uint32_t ui32Attr)

void	uDMAChannelAttributeDisable (uint32_t ui32ChannelNum, uint32_t ui32Attr)

uint32_t	uDMAChannelAttributeGet (uint32_t ui32ChannelNum)

void	uDMAChannelControlSet (uint32_t ui32ChannelStructIndex, uint32_t ui32Control)

void	uDMAChannelTransferSet (uint32_t ui32ChannelStructIndex, uint32_t ui32Mode, void pvSrcAddr, void pvDstAddr, uint32_t ui32TransferSize)

void	uDMAChannelScatterGatherSet (uint32_t ui32ChannelNum, uint32_t ui32TaskCount, void *pvTaskList, uint32_t ui32IsPeriphSG)

uint32_t	uDMAChannelSizeGet (uint32_t ui32ChannelStructIndex)

uint32_t	uDMAChannelModeGet (uint32_t ui32ChannelStructIndex)

void	uDMAIntRegister (uint32_t ui32IntChannel, void(*pfnHandler)(void))

void	uDMAIntUnregister (uint32_t ui32IntChannel)

uint32_t	uDMAIntStatus (void)

void	uDMAIntClear (uint32_t ui32ChanMask)

void	uDMAChannelAssign (uint32_t ui32Mapping)

void	uDMAChannelSelectSecondary (uint32_t ui32SecPeriphs)

void	uDMAChannelSelectDefault (uint32_t ui32DefPeriphs)

Detailed Description

Macro Definition Documentation

#define uDMATaskStructEntry	(	ui32TransferCount,
		ui32ItemSize,
		ui32SrcIncrement,
		pvSrcAddr,
		ui32DstIncrement,
		pvDstAddr,
		ui32ArbSize,
		ui32Mode
	)

Value:

{                                                                         \
        (((ui32SrcIncrement) == UDMA_SRC_INC_NONE) ? (void *)(pvSrcAddr) :    \
            ((void *)(&((uint8_t *)(pvSrcAddr))[((ui32TransferCount) <<       \
                                         ((ui32SrcIncrement) >> 26)) - 1]))), \
            (((ui32DstIncrement) == UDMA_DST_INC_NONE) ? (void *)(pvDstAddr) :\
            ((void *)(&((uint8_t *)(pvDstAddr))[((ui32TransferCount) <<       \
                                         ((ui32DstIncrement) >> 30)) - 1]))), \
        (ui32SrcIncrement) | (ui32DstIncrement) | (ui32ItemSize) |            \
            (ui32ArbSize) |                                                   \
        (((ui32TransferCount) - 1) << 4) |                                    \
        ((((ui32Mode) == UDMA_MODE_MEM_SCATTER_GATHER) ||                     \
          ((ui32Mode) == UDMA_MODE_PER_SCATTER_GATHER)) ?                     \
                (ui32Mode) | UDMA_MODE_ALT_SELECT : (ui32Mode)), 0            \
    }

A helper macro for building scatter-gather task table entries.

Parameters

ui32TransferCount	is the count of items to transfer for this task.
ui32ItemSize	is the bit size of the items to transfer for this task.
ui32SrcIncrement	is the bit size increment for source data.
pvSrcAddr	is the starting address of the data to transfer.
ui32DstIncrement	is the bit size increment for destination data.
pvDstAddr	is the starting address of the destination data.
ui32ArbSize	is the arbitration size to use for the transfer task.
ui32Mode	is the transfer mode for this task.

This macro is intended to be used to help populate a table of uDMA tasks for a scatter-gather transfer. This macro will calculate the values for the fields of a task structure entry based on the input parameters.

There are specific requirements for the values of each parameter. No checking is done so it is up to the caller to ensure that correct values are used for the parameters.

The ui32TransferCount parameter is the number of items that will be transferred by this task. It must be in the range 1-1024.

The ui32ItemSize parameter is the bit size of the transfer data. It must be one of UDMA_SIZE_8, UDMA_SIZE_16, or UDMA_SIZE_32.

The ui32SrcIncrement parameter is the increment size for the source data. It must be one of UDMA_SRC_INC_8, UDMA_SRC_INC_16, UDMA_SRC_INC_32, or UDMA_SRC_INC_NONE.

The pvSrcAddr parameter is a void pointer to the beginning of the source data.

The ui32DstIncrement parameter is the increment size for the destination data. It must be one of UDMA_DST_INC_8, UDMA_DST_INC_16, UDMA_DST_INC_32, or UDMA_DST_INC_NONE.

The pvDstAddr parameter is a void pointer to the beginning of the location where the data will be transferred.

The ui32ArbSize parameter is the arbitration size for the transfer, and must be one of UDMA_ARB_1, UDMA_ARB_2, UDMA_ARB_4, and so on up to UDMA_ARB_1024. This is used to select the arbitration size in powers of 2, from 1 to 1024.

The ui32Mode parameter is the mode to use for this transfer task. It must be one of UDMA_MODE_BASIC, UDMA_MODE_AUTO, UDMA_MODE_MEM_SCATTER_GATHER, or UDMA_MODE_PER_SCATTER_GATHER. Note that normally all tasks will be one of the scatter-gather modes while the last task is a task list will be AUTO or BASIC.

This macro is intended to be used to initialize individual entries of a structure of tDMAControlTable type, like this:

//!     tDMAControlTable MyTaskList[] =
//!     {
//!         uDMATaskStructEntry(Task1Count, UDMA_SIZE_8,
//!                             UDMA_SRC_INC_8, MySourceBuf,
//!                             UDMA_DST_INC_8, MyDestBuf,
//!                             UDMA_ARB_8, UDMA_MODE_MEM_SCATTER_GATHER),
//!         uDMATaskStructEntry(Task2Count, ...),
//!     }
//!

\return Nothing; this is not a function.

Definition at line 161 of file udma.h.

Function Documentation

void uDMAChannelAssign ( uint32_t ui32Mapping )

Assigns a peripheral mapping for a uDMA channel.

Parameters

ui32Mapping is a macro specifying the peripheral assignment for a channel.

This function assigns a peripheral mapping to a uDMA channel. It is used to select which peripheral is used for a uDMA channel. The parameter ui32Mapping should be one of the macros named UDMA_CHn_tttt from the header file udma.h. For example, to assign uDMA channel 0 to the UART2 RX channel, the parameter should be the macro UDMA_CH0_UART2RX.

Please consult the Tiva data sheet for a table showing all the possible peripheral assignments for the uDMA channels for a particular device.

Note: This function is only available on devices that have the DMA Channel Map Select registers (DMACHMAP0-3). Please consult the data sheet for your part.

Returns: None.

Definition at line 1224 of file udma.c.

References ASSERT, HWREG, and UDMA_CHMAP0.

 {
     uint32_t ui32MapReg;
     uint_fast8_t ui8MapShift;
     uint_fast8_t ui8ChannelNum;
 
     //
     // Check the parameters
     //
     ASSERT((ui32Mapping & 0xffffff00) < 0x00050000);
 
     //
     // Extract the channel number and map encoding value from the parameter.
     //
     ui8ChannelNum = ui32Mapping & 0xff;
     ui32Mapping = ui32Mapping >> 16;
 
     //
     // Find the uDMA channel mapping register and shift value to use for this
     // channel
     //
     ui32MapReg = UDMA_CHMAP0 + (uint32_t)((ui8ChannelNum / 8) * 4);
     ui8MapShift = (ui8ChannelNum % 8) * 4;
 
     //
     // Set the channel map encoding for this channel
     //
     HWREG(ui32MapReg) = (HWREG(ui32MapReg) & ~(0xf << ui8MapShift)) |
                         ui32Mapping << ui8MapShift;
 }

void uDMAChannelAttributeDisable	(	uint32_t	ui32ChannelNum,
		uint32_t	ui32Attr
	)

Disables attributes of a uDMA channel.

Parameters

ui32ChannelNum	is the channel to configure.
ui32Attr	is a combination of attributes for the channel.

This function is used to disable attributes of a uDMA channel.

The ui32Attr parameter is the logical OR of any of the following:

UDMA_ATTR_USEBURST is used to restrict transfers to use only burst mode.
UDMA_ATTR_ALTSELECT is used to select the alternate control structure for this channel.
UDMA_ATTR_HIGH_PRIORITY is used to set this channel to high priority.
UDMA_ATTR_REQMASK is used to mask the hardware request signal from the peripheral for this channel.

Returns: None.

Definition at line 429 of file udma.c.

References ASSERT, HWREG, UDMA_ALTCLR, UDMA_ATTR_ALTSELECT, UDMA_ATTR_HIGH_PRIORITY, UDMA_ATTR_REQMASK, UDMA_ATTR_USEBURST, UDMA_PRIOCLR, UDMA_REQMASKCLR, and UDMA_USEBURSTCLR.

 {
     //
     // Check the arguments.
     //
     ASSERT((ui32ChannelNum & 0xffff) < 32);
     ASSERT((ui32Attr & ~(UDMA_ATTR_USEBURST | UDMA_ATTR_ALTSELECT |
                          UDMA_ATTR_HIGH_PRIORITY | UDMA_ATTR_REQMASK)) == 0);
 
     //
     // In case a channel selector macro (like UDMA_CH0_USB0EP1RX) was
     // passed as the ui32ChannelNum parameter, extract just the channel number
     // from this parameter.
     //
     ui32ChannelNum &= 0x1f;
 
     //
     // Clear the useburst bit for this channel if set in ui32Config.
     //
     if(ui32Attr & UDMA_ATTR_USEBURST)
     {
         HWREG(UDMA_USEBURSTCLR) = 1 << ui32ChannelNum;
     }
 
     //
     // Clear the alternate control select bit for this channel, if set in
     // ui32Config.
     //
     if(ui32Attr & UDMA_ATTR_ALTSELECT)
     {
         HWREG(UDMA_ALTCLR) = 1 << ui32ChannelNum;
     }
 
     //
     // Clear the high priority bit for this channel, if set in ui32Config.
     //
     if(ui32Attr & UDMA_ATTR_HIGH_PRIORITY)
     {
         HWREG(UDMA_PRIOCLR) = 1 << ui32ChannelNum;
     }
 
     //
     // Clear the request mask bit for this channel, if set in ui32Config.
     //
     if(ui32Attr & UDMA_ATTR_REQMASK)
     {
         HWREG(UDMA_REQMASKCLR) = 1 << ui32ChannelNum;
     }
 }

void uDMAChannelAttributeEnable	(	uint32_t	ui32ChannelNum,
		uint32_t	ui32Attr
	)

Enables attributes of a uDMA channel.

Parameters

ui32ChannelNum	is the channel to configure.
ui32Attr	is a combination of attributes for the channel.

This function is used to enable attributes of a uDMA channel.

The ui32Attr parameter is the logical OR of any of the following:

UDMA_ATTR_USEBURST is used to restrict transfers to use only burst mode.
UDMA_ATTR_ALTSELECT is used to select the alternate control structure for this channel (it is very unlikely that this flag should be used).
UDMA_ATTR_HIGH_PRIORITY is used to set this channel to high priority.
UDMA_ATTR_REQMASK is used to mask the hardware request signal from the peripheral for this channel.

Returns: None.

Definition at line 356 of file udma.c.

References ASSERT, HWREG, UDMA_ALTSET, UDMA_ATTR_ALTSELECT, UDMA_ATTR_HIGH_PRIORITY, UDMA_ATTR_REQMASK, UDMA_ATTR_USEBURST, UDMA_PRIOSET, UDMA_REQMASKSET, and UDMA_USEBURSTSET.

 {
     //
     // Check the arguments.
     //
     ASSERT((ui32ChannelNum & 0xffff) < 32);
     ASSERT((ui32Attr & ~(UDMA_ATTR_USEBURST | UDMA_ATTR_ALTSELECT |
                          UDMA_ATTR_HIGH_PRIORITY | UDMA_ATTR_REQMASK)) == 0);
 
     //
     // In case a channel selector macro (like UDMA_CH0_USB0EP1RX) was
     // passed as the ui32ChannelNum parameter, extract just the channel number
     // from this parameter.
     //
     ui32ChannelNum &= 0x1f;
 
     //
     // Set the useburst bit for this channel if set in ui32Config.
     //
     if(ui32Attr & UDMA_ATTR_USEBURST)
     {
         HWREG(UDMA_USEBURSTSET) = 1 << ui32ChannelNum;
     }
 
     //
     // Set the alternate control select bit for this channel,
     // if set in ui32Config.
     //
     if(ui32Attr & UDMA_ATTR_ALTSELECT)
     {
         HWREG(UDMA_ALTSET) = 1 << ui32ChannelNum;
     }
 
     //
     // Set the high priority bit for this channel, if set in ui32Config.
     //
     if(ui32Attr & UDMA_ATTR_HIGH_PRIORITY)
     {
         HWREG(UDMA_PRIOSET) = 1 << ui32ChannelNum;
     }
 
     //
     // Set the request mask bit for this channel, if set in ui32Config.
     //
     if(ui32Attr & UDMA_ATTR_REQMASK)
     {
         HWREG(UDMA_REQMASKSET) = 1 << ui32ChannelNum;
     }
 }

uint32_t uDMAChannelAttributeGet ( uint32_t ui32ChannelNum )

Gets the enabled attributes of a uDMA channel.

Parameters

ui32ChannelNum is the channel to configure.

This function returns a combination of flags representing the attributes of the uDMA channel.

Returns

Returns the logical OR of the attributes of the uDMA channel, which can be any of the following:

UDMA_ATTR_USEBURST is used to restrict transfers to use only burst mode.
UDMA_ATTR_ALTSELECT is used to select the alternate control structure for this channel.
UDMA_ATTR_HIGH_PRIORITY is used to set this channel to high priority.
UDMA_ATTR_REQMASK is used to mask the hardware request signal from the peripheral for this channel.

Definition at line 500 of file udma.c.

References ASSERT, HWREG, UDMA_ALTSET, UDMA_ATTR_ALTSELECT, UDMA_ATTR_HIGH_PRIORITY, UDMA_ATTR_REQMASK, UDMA_ATTR_USEBURST, UDMA_PRIOSET, UDMA_REQMASKSET, and UDMA_USEBURSTSET.

 {
     uint32_t ui32Attr = 0;
 
     //
     // Check the arguments.
     //
     ASSERT((ui32ChannelNum & 0xffff) < 32);
 
     //
     // In case a channel selector macro (like UDMA_CH0_USB0EP1RX) was
     // passed as the ui32ChannelNum parameter, extract just the channel number
     // from this parameter.
     //
     ui32ChannelNum &= 0x1f;
 
     //
     // Check to see if useburst bit is set for this channel.
     //
     if(HWREG(UDMA_USEBURSTSET) & (1 << ui32ChannelNum))
     {
         ui32Attr |= UDMA_ATTR_USEBURST;
     }
 
     //
     // Check to see if the alternate control bit is set for this channel.
     //
     if(HWREG(UDMA_ALTSET) & (1 << ui32ChannelNum))
     {
         ui32Attr |= UDMA_ATTR_ALTSELECT;
     }
 
     //
     // Check to see if the high priority bit is set for this channel.
     //
     if(HWREG(UDMA_PRIOSET) & (1 << ui32ChannelNum))
     {
         ui32Attr |= UDMA_ATTR_HIGH_PRIORITY;
     }
 
     //
     // Check to see if the request mask bit is set for this channel.
     //
     if(HWREG(UDMA_REQMASKSET) & (1 << ui32ChannelNum))
     {
         ui32Attr |= UDMA_ATTR_REQMASK;
     }
 
     //
     // Return the configuration flags.
     //
     return(ui32Attr);
 }

void uDMAChannelControlSet	(	uint32_t	ui32ChannelStructIndex,
		uint32_t	ui32Control
	)

Sets the control parameters for a uDMA channel control structure.

Parameters

ui32ChannelStructIndex	is the logical OR of the uDMA channel number with UDMA_PRI_SELECT or UDMA_ALT_SELECT.
ui32Control	is logical OR of several control values to set the control parameters for the channel.

This function is used to set control parameters for a uDMA transfer. These parameters are typically not changed often.

The ui32ChannelStructIndex parameter should be the logical OR of the channel number with one of UDMA_PRI_SELECT or UDMA_ALT_SELECT to choose whether the primary or alternate data structure is used.

The ui32Control parameter is the logical OR of five values: the data size, the source address increment, the destination address increment, the arbitration size, and the use burst flag. The choices available for each of these values is described below.

Choose the data size from one of UDMA_SIZE_8, UDMA_SIZE_16, or UDMA_SIZE_32 to select a data size of 8, 16, or 32 bits.

Choose the source address increment from one of UDMA_SRC_INC_8, UDMA_SRC_INC_16, UDMA_SRC_INC_32, or UDMA_SRC_INC_NONE to select an address increment of 8-bit bytes, 16-bit half-words, 32-bit words, or to select non-incrementing.

Choose the destination address increment from one of UDMA_DST_INC_8, UDMA_DST_INC_16, UDMA_DST_INC_32, or UDMA_DST_INC_NONE to select an address increment of 8-bit bytes, 16-bit half-words, 32-bit words, or to select non-incrementing.

The arbitration size determines how many items are transferred before the uDMA controller re-arbitrates for the bus. Choose the arbitration size from one of UDMA_ARB_1, UDMA_ARB_2, UDMA_ARB_4, UDMA_ARB_8, through UDMA_ARB_1024 to select the arbitration size from 1 to 1024 items, in powers of 2.

The value UDMA_NEXT_USEBURST is used to force the channel to only respond to burst requests at the tail end of a scatter-gather transfer.

Note: The address increment cannot be smaller than the data size.

Returns: None.

Definition at line 603 of file udma.c.

References ASSERT, HWREG, UDMA_CHCTL_ARBSIZE_M, UDMA_CHCTL_DSTINC_M, UDMA_CHCTL_DSTSIZE_M, UDMA_CHCTL_NXTUSEBURST, UDMA_CHCTL_SRCINC_M, UDMA_CHCTL_SRCSIZE_M, UDMA_CTLBASE, and tDMAControlTable::ui32Control.

 {
     tDMAControlTable *psCtl;
 
     //
     // Check the arguments.
     //
     ASSERT((ui32ChannelStructIndex & 0xffff) < 64);
     ASSERT(HWREG(UDMA_CTLBASE) != 0);
 
     //
     // In case a channel selector macro (like UDMA_CH0_USB0EP1RX) was
     // passed as the ui32ChannelStructIndex parameter, extract just the channel
     // index from this parameter.
     //
     ui32ChannelStructIndex &= 0x3f;
 
     //
     // Get the base address of the control table.
     //
     psCtl = (tDMAControlTable *)HWREG(UDMA_CTLBASE);
 
     //
     // Get the current control word value and mask off the fields to be
     // changed, then OR in the new settings.
     //
     psCtl[ui32ChannelStructIndex].ui32Control =
         ((psCtl[ui32ChannelStructIndex].ui32Control &
           ~(UDMA_CHCTL_DSTINC_M |
             UDMA_CHCTL_DSTSIZE_M |
             UDMA_CHCTL_SRCINC_M |
             UDMA_CHCTL_SRCSIZE_M |
             UDMA_CHCTL_ARBSIZE_M |
             UDMA_CHCTL_NXTUSEBURST)) |
          ui32Control);
 }

void uDMAChannelDisable ( uint32_t ui32ChannelNum )

Disables a uDMA channel for operation.

Parameters

ui32ChannelNum is the channel number to disable.

This function disables a specific uDMA channel. Once disabled, a channel cannot respond to uDMA transfer requests until re-enabled via uDMAChannelEnable().

Returns: None.

Definition at line 179 of file udma.c.

References ASSERT, HWREG, and UDMA_ENACLR.

 {
     //
     // Check the arguments.
     //
     ASSERT((ui32ChannelNum & 0xffff) < 32);
 
     //
     // Set the bit for this channel in the enable clear register.
     //
     HWREG(UDMA_ENACLR) = 1 << (ui32ChannelNum & 0x1f);
 }

void uDMAChannelEnable ( uint32_t ui32ChannelNum )

Enables a uDMA channel for operation.

Parameters

ui32ChannelNum is the channel number to enable.

This function enables a specific uDMA channel for use. This function must be used to enable a channel before it can be used to perform a uDMA transfer.

When a uDMA transfer is completed, the channel is automatically disabled by the uDMA controller. Therefore, this function should be called prior to starting up any new transfer.

Returns: None.

Definition at line 152 of file udma.c.

References ASSERT, HWREG, and UDMA_ENASET.

 {
     //
     // Check the arguments.
     //
     ASSERT((ui32ChannelNum & 0xffff) < 32);
 
     //
     // Set the bit for this channel in the enable set register.
     //
     HWREG(UDMA_ENASET) = 1 << (ui32ChannelNum & 0x1f);
 }

bool uDMAChannelIsEnabled ( uint32_t ui32ChannelNum )

Checks if a uDMA channel is enabled for operation.

Parameters

ui32ChannelNum is the channel number to check.

This function checks to see if a specific uDMA channel is enabled. This function can be used to check the status of a transfer, as the channel is automatically disabled at the end of a transfer.

Returns: Returns true if the channel is enabled, false if disabled.

Definition at line 206 of file udma.c.

References ASSERT, HWREG, and UDMA_ENASET.

 {
     //
     // Check the arguments.
     //
     ASSERT((ui32ChannelNum & 0xffff) < 32);
 
     //
     // AND the specified channel bit with the enable register and return the
     // result.
     //
     return((HWREG(UDMA_ENASET) & (1 << (ui32ChannelNum & 0x1f))) ? true :
            false);
 }

uint32_t uDMAChannelModeGet ( uint32_t ui32ChannelStructIndex )

Gets the transfer mode for a uDMA channel control structure.

Parameters

ui32ChannelStructIndex is the logical OR of the uDMA channel number with either UDMA_PRI_SELECT or UDMA_ALT_SELECT.

This function is used to get the transfer mode for the uDMA channel and to query the status of a transfer on a channel. When the transfer is complete the mode is UDMA_MODE_STOP.

Returns: Returns the transfer mode of the specified channel and control structure, which is one of the following values: UDMA_MODE_STOP, UDMA_MODE_BASIC, UDMA_MODE_AUTO, UDMA_MODE_PINGPONG, UDMA_MODE_MEM_SCATTER_GATHER, or UDMA_MODE_PER_SCATTER_GATHER.

Definition at line 1018 of file udma.c.

References ASSERT, HWREG, UDMA_CHCTL_XFERMODE_M, UDMA_CTLBASE, UDMA_MODE_ALT_SELECT, UDMA_MODE_MEM_SCATTER_GATHER, UDMA_MODE_PER_SCATTER_GATHER, and tDMAControlTable::ui32Control.

 {
     tDMAControlTable *psControlTable;
     uint32_t ui32Control;
 
     //
     // Check the arguments.
     //
     ASSERT((ui32ChannelStructIndex & 0xffff) < 64);
     ASSERT(HWREG(UDMA_CTLBASE) != 0);
 
     //
     // In case a channel selector macro (like UDMA_CH0_USB0EP1RX) was
     // passed as the ui32ChannelStructIndex parameter, extract just the channel
     // index from this parameter.
     //
     ui32ChannelStructIndex &= 0x3f;
 
     //
     // Get the base address of the control table.
     //
     psControlTable = (tDMAControlTable *)HWREG(UDMA_CTLBASE);
 
     //
     // Get the current control word value and mask off all but the mode field.
     //
     ui32Control = (psControlTable[ui32ChannelStructIndex].ui32Control &
                    UDMA_CHCTL_XFERMODE_M);
 
     //
     // Check if scatter/gather mode, and if so, mask off the alt bit.
     //
     if(((ui32Control & ~UDMA_MODE_ALT_SELECT) ==
         UDMA_MODE_MEM_SCATTER_GATHER) ||
        ((ui32Control & ~UDMA_MODE_ALT_SELECT) == UDMA_MODE_PER_SCATTER_GATHER))
     {
         ui32Control &= ~UDMA_MODE_ALT_SELECT;
     }
 
     //
     // Return the mode to the caller.
     //
     return(ui32Control);
 }

void uDMAChannelRequest ( uint32_t ui32ChannelNum )

Requests a uDMA channel to start a transfer.

Parameters

ui32ChannelNum is the channel number on which to request a uDMA transfer.

This function allows software to request a uDMA channel to begin a transfer. This function could be used for performing a memory-to-memory transfer, or if for some reason a transfer needs to be initiated by software instead of the peripheral associated with that channel.

Note: If the channel is UDMA_CHANNEL_SW and interrupts are used, then the completion is signaled on the uDMA dedicated interrupt. If a peripheral channel is used, then the completion is signaled on the peripheral's interrupt.

Returns: None.

Definition at line 320 of file udma.c.

References ASSERT, HWREG, and UDMA_SWREQ.

 {
     //
     // Check the arguments.
     //
     ASSERT((ui32ChannelNum & 0xffff) < 32);
 
     //
     // Set the bit for this channel in the software uDMA request register.
     //
     HWREG(UDMA_SWREQ) = 1 << (ui32ChannelNum & 0x1f);
 }

void uDMAChannelScatterGatherSet	(	uint32_t	ui32ChannelNum,
		uint32_t	ui32TaskCount,
		void *	pvTaskList,
		uint32_t	ui32IsPeriphSG
	)

Configures a uDMA channel for scatter-gather mode.

Parameters

ui32ChannelNum	is the uDMA channel number.
ui32TaskCount	is the number of scatter-gather tasks to execute.
pvTaskList	is a pointer to the beginning of the scatter-gather task list.
ui32IsPeriphSG	is a flag to indicate it is a peripheral scatter-gather transfer (else it is memory scatter-gather transfer)

This function is used to configure a channel for scatter-gather mode. The caller must have already set up a task list and must pass a pointer to the start of the task list as the pvTaskList parameter. The ui32TaskCount parameter is the count of tasks in the task list, not the size of the task list. The flag bIsPeriphSG should be used to indicate if scatter-gather should be configured for peripheral or memory operation.

See also: uDMATaskStructEntry

Returns: None.

Definition at line 861 of file udma.c.

References ASSERT, HWREG, tDMAControlTable::pvDstEndAddr, tDMAControlTable::pvSrcEndAddr, UDMA_ALT_SELECT, UDMA_ALTCLR, UDMA_CHCTL_ARBSIZE_4, UDMA_CHCTL_DSTINC_32, UDMA_CHCTL_DSTSIZE_32, UDMA_CHCTL_SRCINC_32, UDMA_CHCTL_SRCSIZE_32, UDMA_CHCTL_XFERMODE_MEM_SG, UDMA_CHCTL_XFERMODE_PER_SG, UDMA_CHCTL_XFERSIZE_S, UDMA_CTLBASE, tDMAControlTable::ui32Control, and tDMAControlTable::ui32Spare.

 {
     tDMAControlTable *psControlTable;
     tDMAControlTable *psTaskTable;
 
     //
     // Check the parameters
     //
     ASSERT((ui32ChannelNum & 0xffff) < 32);
     ASSERT(HWREG(UDMA_CTLBASE) != 0);
     ASSERT(pvTaskList != 0);
     ASSERT(ui32TaskCount <= 1024);
     ASSERT(ui32TaskCount != 0);
 
     //
     // In case a channel selector macro (like UDMA_CH0_USB0EP1RX) was
     // passed as the ui32ChannelNum parameter, extract just the channel number
     // from this parameter.
     //
     ui32ChannelNum &= 0x1f;
 
     //
     // Get the base address of the control table.
     //
     psControlTable = (tDMAControlTable *)HWREG(UDMA_CTLBASE);
 
     //
     // Get a handy pointer to the task list
     //
     psTaskTable = (tDMAControlTable *)pvTaskList;
 
     //
     // Compute the ending address for the source pointer.  This address is the
     // last element of the last task in the task table
     //
     psControlTable[ui32ChannelNum].pvSrcEndAddr =
         &psTaskTable[ui32TaskCount - 1].ui32Spare;
 
     //
     // Compute the ending address for the destination pointer.  This address
     // is the end of the alternate structure for this channel.
     //
     psControlTable[ui32ChannelNum].pvDstEndAddr =
         &psControlTable[ui32ChannelNum | UDMA_ALT_SELECT].ui32Spare;
 
     //
     // Compute the control word.  Most configurable items are fixed for
     // scatter-gather.  Item and increment sizes are all 32-bit and arb
     // size must be 4.  The count is the number of items in the task list
     // times 4 (4 words per task).
     //
     psControlTable[ui32ChannelNum].ui32Control =
         (UDMA_CHCTL_DSTINC_32 | UDMA_CHCTL_DSTSIZE_32 |
          UDMA_CHCTL_SRCINC_32 | UDMA_CHCTL_SRCSIZE_32 |
          UDMA_CHCTL_ARBSIZE_4 |
          (((ui32TaskCount * 4) - 1) << UDMA_CHCTL_XFERSIZE_S) |
          (ui32IsPeriphSG ? UDMA_CHCTL_XFERMODE_PER_SG :
           UDMA_CHCTL_XFERMODE_MEM_SG));
 
     //
     // Scatter-gather operations can leave the alt bit set.  So if doing
     // back to back scatter-gather transfers, the second attempt may not
     // work correctly because the alt bit is set.  Therefore, clear the
     // alt bit here to ensure that it is always cleared before a new SG
     // transfer is started.
     //
     HWREG(UDMA_ALTCLR) = 1 << ui32ChannelNum;
 }

void uDMAChannelSelectDefault ( uint32_t ui32DefPeriphs )

Selects the default peripheral for a set of uDMA channels.

Parameters

ui32DefPeriphs is the logical OR of the uDMA channels for which to use the default peripheral, instead of the secondary peripheral.

This function is used to select the default peripheral assignment for a set of uDMA channels.

The parameter ui32DefPeriphs can be the logical OR of any of the following macros. If one of the macros below is in the list passed to this function, then the default peripheral (marked as DEF) is selected.

UDMA_DEF_USBEP1RX_SEC_UART2RX
UDMA_DEF_USBEP1TX_SEC_UART2TX
UDMA_DEF_USBEP2RX_SEC_TMR3A
UDMA_DEF_USBEP2TX_SEC_TMR3B
UDMA_DEF_USBEP3RX_SEC_TMR2A
UDMA_DEF_USBEP3TX_SEC_TMR2B
UDMA_DEF_ETH0RX_SEC_TMR2A
UDMA_DEF_ETH0TX_SEC_TMR2B
UDMA_DEF_UART0RX_SEC_UART1RX
UDMA_DEF_UART0TX_SEC_UART1TX
UDMA_DEF_SSI0RX_SEC_SSI1RX
UDMA_DEF_SSI0TX_SEC_SSI1TX
UDMA_DEF_RESERVED_SEC_UART2RX
UDMA_DEF_RESERVED_SEC_UART2TX
UDMA_DEF_ADC00_SEC_TMR2A
UDMA_DEF_ADC01_SEC_TMR2B
UDMA_DEF_ADC02_SEC_RESERVED
UDMA_DEF_ADC03_SEC_RESERVED
UDMA_DEF_TMR0A_SEC_TMR1A
UDMA_DEF_TMR0B_SEC_TMR1B
UDMA_DEF_TMR1A_SEC_EPI0RX
UDMA_DEF_TMR1B_SEC_EPI0TX
UDMA_DEF_UART1RX_SEC_RESERVED
UDMA_DEF_UART1TX_SEC_RESERVED
UDMA_DEF_SSI1RX_SEC_ADC10
UDMA_DEF_SSI1TX_SEC_ADC11
UDMA_DEF_RESERVED_SEC_ADC12
UDMA_DEF_RESERVED_SEC_ADC13
UDMA_DEF_I2S0RX_SEC_RESERVED
UDMA_DEF_I2S0TX_SEC_RESERVED

Returns: None.

Definition at line 1370 of file udma.c.

References HWREG, and UDMA_CHASGN.

 {
     //
     // Select the default peripheral for the specified channels.
     //
     HWREG(UDMA_CHASGN) &= ~ui32DefPeriphs;
 }

void uDMAChannelSelectSecondary ( uint32_t ui32SecPeriphs )

Selects the secondary peripheral for a set of uDMA channels.

Parameters

ui32SecPeriphs is the logical OR of the uDMA channels for which to use the secondary peripheral, instead of the default peripheral.

This function is used to select the secondary peripheral assignment for a set of uDMA channels. By selecting the secondary peripheral assignment for a channel, the default peripheral assignment is no longer available for that channel.

The parameter ui32SecPeriphs can be the logical OR of any of the following macros. If one of the macros below is in the list passed to this function, then the secondary peripheral (marked as SEC) is selected.

UDMA_DEF_USBEP1RX_SEC_UART2RX
UDMA_DEF_USBEP1TX_SEC_UART2TX
UDMA_DEF_USBEP2RX_SEC_TMR3A
UDMA_DEF_USBEP2TX_SEC_TMR3B
UDMA_DEF_USBEP3RX_SEC_TMR2A
UDMA_DEF_USBEP3TX_SEC_TMR2B
UDMA_DEF_ETH0RX_SEC_TMR2A
UDMA_DEF_ETH0TX_SEC_TMR2B
UDMA_DEF_UART0RX_SEC_UART1RX
UDMA_DEF_UART0TX_SEC_UART1TX
UDMA_DEF_SSI0RX_SEC_SSI1RX
UDMA_DEF_SSI0TX_SEC_SSI1TX
UDMA_DEF_RESERVED_SEC_UART2RX
UDMA_DEF_RESERVED_SEC_UART2TX
UDMA_DEF_ADC00_SEC_TMR2A
UDMA_DEF_ADC01_SEC_TMR2B
UDMA_DEF_ADC02_SEC_RESERVED
UDMA_DEF_ADC03_SEC_RESERVED
UDMA_DEF_TMR0A_SEC_TMR1A
UDMA_DEF_TMR0B_SEC_TMR1B
UDMA_DEF_TMR1A_SEC_EPI0RX
UDMA_DEF_TMR1B_SEC_EPI0TX
UDMA_DEF_UART1RX_SEC_RESERVED
UDMA_DEF_UART1TX_SEC_RESERVED
UDMA_DEF_SSI1RX_SEC_ADC10
UDMA_DEF_SSI1TX_SEC_ADC11
UDMA_DEF_RESERVED_SEC_ADC12
UDMA_DEF_RESERVED_SEC_ADC13
UDMA_DEF_I2S0RX_SEC_RESERVED
UDMA_DEF_I2S0TX_SEC_RESERVED

Returns: None.

Definition at line 1313 of file udma.c.

References HWREG, and UDMA_CHASGN.

 {
     //
     // Select the secondary peripheral for the specified channels.
     //
     HWREG(UDMA_CHASGN) |= ui32SecPeriphs;
 }

uint32_t uDMAChannelSizeGet ( uint32_t ui32ChannelStructIndex )

Gets the current transfer size for a uDMA channel control structure.

Parameters

ui32ChannelStructIndex is the logical OR of the uDMA channel number with either UDMA_PRI_SELECT or UDMA_ALT_SELECT.

This function is used to get the uDMA transfer size for a channel. The transfer size is the number of items to transfer, where the size of an item might be 8, 16, or 32 bits. If a partial transfer has already occurred, then the number of remaining items is returned. If the transfer is complete, then 0 is returned.

Returns: Returns the number of items remaining to transfer.

Definition at line 948 of file udma.c.

References ASSERT, HWREG, UDMA_CHCTL_XFERMODE_M, UDMA_CHCTL_XFERSIZE_M, UDMA_CTLBASE, and tDMAControlTable::ui32Control.

 {
     tDMAControlTable *psControlTable;
     uint32_t ui32Control;
 
     //
     // Check the arguments.
     //
     ASSERT((ui32ChannelStructIndex & 0xffff) < 64);
     ASSERT(HWREG(UDMA_CTLBASE) != 0);
 
     //
     // In case a channel selector macro (like UDMA_CH0_USB0EP1RX) was
     // passed as the ui32ChannelStructIndex parameter, extract just the channel
     // index from this parameter.
     //
     ui32ChannelStructIndex &= 0x3f;
 
     //
     // Get the base address of the control table.
     //
     psControlTable = (tDMAControlTable *)HWREG(UDMA_CTLBASE);
 
     //
     // Get the current control word value and mask off all but the size field
     // and the mode field.
     //
     ui32Control = (psControlTable[ui32ChannelStructIndex].ui32Control &
                    (UDMA_CHCTL_XFERSIZE_M | UDMA_CHCTL_XFERMODE_M));
 
     //
     // If the size field and mode field are 0 then the transfer is finished
     // and there are no more items to transfer
     //
     if(ui32Control == 0)
     {
         return(0);
     }
 
     //
     // Otherwise, if either the size field or more field is non-zero, then
     // not all the items have been transferred.
     //
     else
     {
         //
         // Shift the size field and add one, then return to user.
         //
         return((ui32Control >> 4) + 1);
     }
 }

void uDMAChannelTransferSet	(	uint32_t	ui32ChannelStructIndex,
		uint32_t	ui32Mode,
		void *	pvSrcAddr,
		void *	pvDstAddr,
		uint32_t	ui32TransferSize
	)

Sets the transfer parameters for a uDMA channel control structure.

Parameters

ui32ChannelStructIndex	is the logical OR of the uDMA channel number with either UDMA_PRI_SELECT or UDMA_ALT_SELECT.
ui32Mode	is the type of uDMA transfer.
pvSrcAddr	is the source address for the transfer.
pvDstAddr	is the destination address for the transfer.
ui32TransferSize	is the number of data items to transfer.

This function is used to configure the parameters for a uDMA transfer. These parameters are not typically changed often. The function uDMAChannelControlSet() MUST be called at least once for this channel prior to calling this function.

The ui32ChannelStructIndex parameter should be the logical OR of the channel number with one of UDMA_PRI_SELECT or UDMA_ALT_SELECT to choose whether the primary or alternate data structure is used.

The ui32Mode parameter should be one of the following values:

UDMA_MODE_STOP stops the uDMA transfer. The controller sets the mode to this value at the end of a transfer.
UDMA_MODE_BASIC to perform a basic transfer based on request.
UDMA_MODE_AUTO to perform a transfer that always completes once started even if the request is removed.
UDMA_MODE_PINGPONG to set up a transfer that switches between the primary and alternate control structures for the channel. This mode allows use of ping-pong buffering for uDMA transfers.
UDMA_MODE_MEM_SCATTER_GATHER to set up a memory scatter-gather transfer.
UDMA_MODE_PER_SCATTER_GATHER to set up a peripheral scatter-gather transfer.

The pvSrcAddr and pvDstAddr parameters are pointers to the first location of the data to be transferred. These addresses should be aligned according to the item size. The compiler takes care of this alignment if the pointers are pointing to storage of the appropriate data type.

The ui32TransferSize parameter is the number of data items, not the number of bytes.

The two scatter-gather modes, memory and peripheral, are actually different depending on whether the primary or alternate control structure is selected. This function looks for the UDMA_PRI_SELECT and UDMA_ALT_SELECT flag along with the channel number and sets the scatter-gather mode as appropriate for the primary or alternate control structure.

The channel must also be enabled using uDMAChannelEnable() after calling this function. The transfer does not begin until the channel has been configured and enabled. Note that the channel is automatically disabled after the transfer is completed, meaning that uDMAChannelEnable() must be called again after setting up the next transfer.

Note: Great care must be taken to not modify a channel control structure that is in use or else the results are unpredictable, including the possibility of undesired data transfers to or from memory or peripherals. For BASIC and AUTO modes, it is safe to make changes when the channel is disabled, or the uDMAChannelModeGet() returns UDMA_MODE_STOP. For PINGPONG or one of the SCATTER_GATHER modes, it is safe to modify the primary or alternate control structure only when the other is being used. The uDMAChannelModeGet() function returns UDMA_MODE_STOP when a channel control structure is inactive and safe to modify.

Returns: None.

Definition at line 710 of file udma.c.

References ASSERT, HWREG, tDMAControlTable::pvDstEndAddr, tDMAControlTable::pvSrcEndAddr, UDMA_ALT_SELECT, UDMA_CHCTL_DSTINC_M, UDMA_CHCTL_SRCINC_M, UDMA_CHCTL_XFERMODE_M, UDMA_CHCTL_XFERSIZE_M, UDMA_CTLBASE, UDMA_DST_INC_NONE, UDMA_MODE_ALT_SELECT, UDMA_MODE_MEM_SCATTER_GATHER, UDMA_MODE_PER_SCATTER_GATHER, UDMA_SRC_INC_NONE, and tDMAControlTable::ui32Control.

 {
     tDMAControlTable *psControlTable;
     uint32_t ui32Control;
     uint32_t ui32Inc;
     uint32_t ui32BufferBytes;
 
     //
     // Check the arguments.
     //
     ASSERT((ui32ChannelStructIndex & 0xffff) < 64);
     ASSERT(HWREG(UDMA_CTLBASE) != 0);
     ASSERT(ui32Mode <= UDMA_MODE_PER_SCATTER_GATHER);
     ASSERT((uint32_t)pvSrcAddr >= 0x20000000);
     ASSERT((uint32_t)pvDstAddr >= 0x20000000);
     ASSERT((ui32TransferSize != 0) && (ui32TransferSize <= 1024));
 
     //
     // In case a channel selector macro (like UDMA_CH0_USB0EP1RX) was
     // passed as the ui32ChannelStructIndex parameter, extract just the channel
     // index from this parameter.
     //
     ui32ChannelStructIndex &= 0x3f;
 
     //
     // Get the base address of the control table.
     //
     psControlTable = (tDMAControlTable *)HWREG(UDMA_CTLBASE);
 
     //
     // Get the current control word value and mask off the mode and size
     // fields.
     //
     ui32Control = (psControlTable[ui32ChannelStructIndex].ui32Control &
                    ~(UDMA_CHCTL_XFERSIZE_M | UDMA_CHCTL_XFERMODE_M));
 
     //
     // Adjust the mode if the alt control structure is selected.
     //
     if(ui32ChannelStructIndex & UDMA_ALT_SELECT)
     {
         if((ui32Mode == UDMA_MODE_MEM_SCATTER_GATHER) ||
            (ui32Mode == UDMA_MODE_PER_SCATTER_GATHER))
         {
             ui32Mode |= UDMA_MODE_ALT_SELECT;
         }
     }
 
     //
     // Set the transfer size and mode in the control word (but don't write the
     // control word yet as it could kick off a transfer).
     //
     ui32Control |= ui32Mode | ((ui32TransferSize - 1) << 4);
 
     //
     // Get the address increment value for the source, from the control word.
     //
     ui32Inc = (ui32Control & UDMA_CHCTL_SRCINC_M);
 
     //
     // Compute the ending source address of the transfer.  If the source
     // increment is set to none, then the ending address is the same as the
     // beginning.
     //
     if(ui32Inc != UDMA_SRC_INC_NONE)
     {
         ui32Inc = ui32Inc >> 26;
         ui32BufferBytes = ui32TransferSize << ui32Inc;
         pvSrcAddr = (void *)((uint32_t)pvSrcAddr + ui32BufferBytes - 1);
     }
 
     //
     // Load the source ending address into the control block.
     //
     psControlTable[ui32ChannelStructIndex].pvSrcEndAddr = pvSrcAddr;
 
     //
     // Get the address increment value for the destination, from the control
     // word.
     //
     ui32Inc = ui32Control & UDMA_CHCTL_DSTINC_M;
 
     //
     // Compute the ending destination address of the transfer.  If the
     // destination increment is set to none, then the ending address is the
     // same as the beginning.
     //
     if(ui32Inc != UDMA_DST_INC_NONE)
     {
         //
         // There is a special case if this is setting up a scatter-gather
         // transfer.  The destination pointer must point to the end of
         // the alternate structure for this channel instead of calculating
         // the end of the buffer in the normal way.
         //
         if((ui32Mode == UDMA_MODE_MEM_SCATTER_GATHER) ||
            (ui32Mode == UDMA_MODE_PER_SCATTER_GATHER))
         {
             pvDstAddr =
                 (void *)&psControlTable[ui32ChannelStructIndex |
                                         UDMA_ALT_SELECT].ui32Spare;
         }
         //
         // Not a scatter-gather transfer, calculate end pointer normally.
         //
         else
         {
             ui32Inc = ui32Inc >> 30;
             ui32BufferBytes = ui32TransferSize << ui32Inc;
             pvDstAddr = (void *)((uint32_t)pvDstAddr + ui32BufferBytes - 1);
         }
     }
 
     //
     // Load the destination ending address into the control block.
     //
     psControlTable[ui32ChannelStructIndex].pvDstEndAddr = pvDstAddr;
 
     //
     // Write the new control word value.
     //
     psControlTable[ui32ChannelStructIndex].ui32Control = ui32Control;
 }

void* uDMAControlAlternateBaseGet ( void )

Gets the base address for the channel control table alternate structures.

This function gets the base address of the second half of the channel control table that holds the alternate control structures for each channel.

Returns: Returns a pointer to the base address of the second half of the channel control table.

Definition at line 290 of file udma.c.

References HWREG, and UDMA_ALTBASE.

 {
     //
     // Read the current value of the control base register and return it to
     // the caller.
     //
     return((void *)HWREG(UDMA_ALTBASE));
 }

void* uDMAControlBaseGet ( void )

Gets the base address for the channel control table.

This function gets the base address of the channel control table. This table resides in system memory and holds control information for each uDMA channel.

Returns: Returns a pointer to the base address of the channel control table.

Definition at line 269 of file udma.c.

References HWREG, and UDMA_CTLBASE.

 {
     //
     // Read the current value of the control base register and return it to
     // the caller.
     //
     return((void *)HWREG(UDMA_CTLBASE));
 }

void uDMAControlBaseSet ( void * psControlTable )

Sets the base address for the channel control table.

Parameters

psControlTable is a pointer to the 1024-byte-aligned base address of the uDMA channel control table.

This function configures the base address of the channel control table. This table resides in system memory and holds control information for each uDMA channel. The table must be aligned on a 1024-byte boundary. The base address must be configured before any of the channel functions can be used.

The size of the channel control table depends on the number of uDMA channels and the transfer modes that are used. Refer to the introductory text and the microcontroller datasheet for more information about the channel control table.

Returns: None.

Definition at line 242 of file udma.c.

References ASSERT, HWREG, and UDMA_CTLBASE.

 {
     //
     // Check the arguments.
     //
     ASSERT(((uint32_t)psControlTable & ~0x3FF) ==
            (uint32_t)psControlTable);
     ASSERT((uint32_t)psControlTable >= 0x20000000);
 
     //
     // Program the base address into the register.
     //
     HWREG(UDMA_CTLBASE) = (uint32_t)psControlTable;
 }

void uDMADisable ( void )

Disables the uDMA controller for use.

This function disables the uDMA controller. Once disabled, the uDMA controller cannot operate until re-enabled with uDMAEnable().

Returns: None.

Definition at line 86 of file udma.c.

References HWREG, and UDMA_CFG.

 {
     //
     // Clear the master enable bit in the config register.
     //
     HWREG(UDMA_CFG) = 0;
 }

void uDMAEnable ( void )

Enables the uDMA controller for use.

This function enables the uDMA controller. The uDMA controller must be enabled before it can be configured and used.

Returns: None.

Definition at line 67 of file udma.c.

References HWREG, UDMA_CFG, and UDMA_CFG_MASTEN.

 {
     //
     // Set the master enable bit in the config register.
     //
     HWREG(UDMA_CFG) = UDMA_CFG_MASTEN;
 }

void uDMAErrorStatusClear ( void )

Clears the uDMA error interrupt.

This function clears a pending uDMA error interrupt. This function should be called from within the uDMA error interrupt handler to clear the interrupt.

Returns: None.

Definition at line 126 of file udma.c.

References HWREG, and UDMA_ERRCLR.

 {
     //
     // Clear the uDMA error interrupt.
     //
     HWREG(UDMA_ERRCLR) = 1;
 }

uint32_t uDMAErrorStatusGet ( void )

Gets the uDMA error status.

This function returns the uDMA error status. It should be called from within the uDMA error interrupt handler to determine if a uDMA error occurred.

Returns: Returns non-zero if a uDMA error is pending.

Definition at line 106 of file udma.c.

References HWREG, and UDMA_ERRCLR.

 {
     //
     // Return the uDMA error status.
     //
     return(HWREG(UDMA_ERRCLR));
 }

void uDMAIntClear ( uint32_t ui32ChanMask )

Clears uDMA interrupt status.

Parameters

ui32ChanMask is a 32-bit mask with one bit for each uDMA channel.

This function clears bits in the uDMA interrupt status register according to which bits are set in ui32ChanMask. There is one bit for each channel. If a a bit is set in ui32ChanMask, then that corresponding channel's interrupt status is cleared (if it was set).

Note: This function is only available on devices that have the DMA Channel Interrupt Status Register (DMACHIS). Please consult the data sheet for your part. Devices without the DMACHIS register have uDMA done status in the interrupt registers in the peripheral memory maps.

Returns: None.

Definition at line 1191 of file udma.c.

References HWREG, and UDMA_CHIS.

 {
     //
     // Clear the requested bits in the uDMA interrupt status register
     //
     HWREG(UDMA_CHIS) = ui32ChanMask;
 }

void uDMAIntRegister	(	uint32_t	ui32IntChannel,
		void(*)(void)	pfnHandler
	)

Registers an interrupt handler for the uDMA controller.

Parameters

ui32IntChannel	identifies which uDMA interrupt is to be registered.
pfnHandler	is a pointer to the function to be called when the interrupt is activated.

This function registers and enables the handler to be called when the uDMA controller generates an interrupt. The ui32IntChannel parameter should be one of the following:

UDMA_INT_SW to register an interrupt handler to process interrupts from the uDMA software channel (UDMA_CHANNEL_SW)
UDMA_INT_ERR to register an interrupt handler to process uDMA error interrupts

See also: IntRegister() for important information about registering interrupt handlers.

Note: The interrupt handler for the uDMA is for transfer completion when the channel UDMA_CHANNEL_SW is used and for error interrupts. The interrupts for each peripheral channel are handled through the individual peripheral interrupt handlers.

Returns: None.

Definition at line 1092 of file udma.c.

References ASSERT, IntEnable(), IntRegister(), UDMA_INT_ERR, and UDMA_INT_SW.

 {
     //
     // Check the arguments.
     //
     ASSERT(pfnHandler);
     ASSERT((ui32IntChannel == UDMA_INT_SW) ||
            (ui32IntChannel == UDMA_INT_ERR));
 
     //
     // Register the interrupt handler.
     //
     IntRegister(ui32IntChannel, pfnHandler);
 
     //
     // Enable the memory management fault.
     //
     IntEnable(ui32IntChannel);
 }

Here is the call graph for this function:

uint32_t uDMAIntStatus ( void )

Gets the uDMA controller channel interrupt status.

This function is used to get the interrupt status of the uDMA controller. The returned value is a 32-bit bit mask that indicates which channels are requesting an interrupt. This function can be used from within an interrupt handler to determine or confirm which uDMA channel has requested an interrupt.

Note: This function is only available on devices that have the DMA Channel Interrupt Status Register (DMACHIS). Please consult the data sheet for your part.

Returns: Returns a 32-bit mask which indicates requesting uDMA channels. There is a bit for each channel and a 1 indicates that the channel is requesting an interrupt. Multiple bits can be set.

Definition at line 1163 of file udma.c.

References HWREG, and UDMA_CHIS.

 {
     //
     // Return the value of the uDMA interrupt status register
     //
     return(HWREG(UDMA_CHIS));
 }

void uDMAIntUnregister ( uint32_t ui32IntChannel )

Unregisters an interrupt handler for the uDMA controller.

Parameters

ui32IntChannel identifies which uDMA interrupt to unregister.

This function disables and unregisters the handler to be called for the specified uDMA interrupt. The ui32IntChannel parameter should be one of UDMA_INT_SW or UDMA_INT_ERR as documented for the function uDMAIntRegister().

See also: IntRegister() for important information about registering interrupt handlers.

Returns: None.

Definition at line 1130 of file udma.c.

References IntDisable(), and IntUnregister().

 {
     //
     // Disable the interrupt.
     //
     IntDisable(ui32IntChannel);
 
     //
     // Unregister the interrupt handler.
     //
     IntUnregister(ui32IntChannel);
 }

Here is the call graph for this function:

Data Structures

Macros

Functions

Detailed Description

Macro Definition Documentation

Function Documentation