[udma.h] Micro Direct Memory Access

Data Structures
struct	tDMAControlTable
	A structure that defines an entry in the channel control table. More...

Functions
static void	uDMAEnable (uint32_t ui32Base)
	Enables the uDMA controller for use. More...
static void	uDMADisable (uint32_t ui32Base)
	Disables the uDMA controller for use. More...
static uint32_t	uDMAErrorStatusGet (uint32_t ui32Base)
	Gets the uDMA error status. More...
static void	uDMAErrorStatusClear (uint32_t ui32Base)
	Clears the uDMA error interrupt. More...
static void	uDMAChannelEnable (uint32_t ui32Base, uint32_t ui32ChannelNum)
	Enables a uDMA channel for operation. More...
static void	uDMAChannelDisable (uint32_t ui32Base, uint32_t ui32ChannelNum)
	Disables a uDMA channel for operation. More...
static bool	uDMAChannelIsEnabled (uint32_t ui32Base, uint32_t ui32ChannelNum)
	Checks if a uDMA channel is enabled for operation. More...
static void	uDMAControlBaseSet (uint32_t ui32Base, void *pControlTable)
	Sets the base address for the channel control table. More...
static void *	uDMAControlBaseGet (uint32_t ui32Base)
	Gets the base address for the channel control table. More...
static void *	uDMAControlAlternateBaseGet (uint32_t ui32Base)
	Gets the base address for the channel control table alternate structures. More...
static void	uDMAChannelRequest (uint32_t ui32Base, uint32_t ui32ChannelNum)
	Requests a uDMA channel to start a transfer. More...
void	uDMAChannelAttributeEnable (uint32_t ui32Base, uint32_t ui32ChannelNum, uint32_t ui32Attr)
	Enables attributes of a uDMA channel. More...
void	uDMAChannelAttributeDisable (uint32_t ui32Base, uint32_t ui32ChannelNum, uint32_t ui32Attr)
	Disables attributes of an uDMA channel. More...
uint32_t	uDMAChannelAttributeGet (uint32_t ui32Base, uint32_t ui32ChannelNum)
	Gets the enabled attributes of a uDMA channel. More...
void	uDMAChannelControlSet (uint32_t ui32Base, uint32_t ui32ChannelStructIndex, uint32_t ui32Control)
	Sets the control parameters for a uDMA channel control structure. More...
void	uDMAChannelTransferSet (uint32_t ui32Base, uint32_t ui32ChannelStructIndex, uint32_t ui32Mode, void *pvSrcAddr, void *pvDstAddr, uint32_t ui32TransferSize)
	Sets the transfer parameters for a uDMA channel control structure. More...
void	uDMAChannelScatterGatherSet (uint32_t ui32Base, uint32_t ui32ChannelNum, uint32_t ui32TaskCount, void *pvTaskList, uint32_t ui32IsPeriphSG)
	Configures a uDMA channel for scatter-gather mode. More...
uint32_t	uDMAChannelSizeGet (uint32_t ui32Base, uint32_t ui32ChannelStructIndex)
	Gets the current transfer size for a uDMA channel control structure. More...
uint32_t	uDMAChannelModeGet (uint32_t ui32Base, uint32_t ui32ChannelStructIndex)
	Gets the transfer mode for a uDMA channel control structure. More...
static void	uDMAIntRegister (uint32_t ui32Base, uint32_t ui32IntChannel, void(*pfnHandler)(void))
	Registers an interrupt handler for the uDMA controller in the dynamic interrupt table. More...
static void	uDMAIntUnregister (uint32_t ui32Base, uint32_t ui32IntChannel)
	Unregisters an interrupt handler for the uDMA controller in the dynamic interrupt table. More...
static void	uDMAIntClear (uint32_t ui32Base, uint32_t ui32ChanMask)
	Clears uDMA interrupt done status. More...
static uint32_t	uDMAIntStatus (uint32_t ui32Base)
	Get the uDMA interrupt status. More...
static void	uDMAIntSwEventEnable (uint32_t ui32Base, uint32_t ui32IntChannel)
	Enable interrupt on software event driven uDMA transfers. More...
static void	uDMAIntSwEventDisable (uint32_t ui32Base, uint32_t ui32IntChannel)
	Disable interrupt on software event driven uDMA transfers. More...
static uint32_t	uDMAGetStatus (uint32_t ui32Base)
	Return the status of the uDMA module. More...
static void	uDMAChannelPrioritySet (uint32_t ui32Base, uint32_t ui32ChannelNum)
	Set the priority of a uDMA channel. More...
static bool	uDMAChannelPriorityGet (uint32_t ui32Base, uint32_t ui32ChannelNum)
	Get the priority of a uDMA channel. More...
static void	uDMAChannelPriorityClear (uint32_t ui32Base, uint32_t ui32ChannelNum)
	Clear the priority of a uDMA channel. More...

Detailed Description

Function Documentation

void uDMAChannelAttributeDisable	(	uint32_t	ui32Base,
		uint32_t	ui32ChannelNum,
		uint32_t	ui32Attr
	)

Disables attributes of an uDMA channel.

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

Parameters

ui32Base	is the base address of the uDMA port.
ui32ChannelNum	is the channel to configure.
ui32Attr	is a combination of attributes for the channel. The parameter is the bitwise OR of any of the following: UDMA_ATTR_USEBURST is used to restrict transfers to use only a 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

{
    // Check the arguments.
    ASSERT(uDMABaseValid(ui32Base));
    ASSERT(ui32ChannelNum < UDMA_NUM_CHANNELS);
    ASSERT((ui32Attr & ~(UDMA_ATTR_USEBURST | UDMA_ATTR_ALTSELECT |
                         UDMA_ATTR_HIGH_PRIORITY | UDMA_ATTR_REQMASK)) == 0);

    // Clear the useburst bit for this channel if set in ui32Attr.
    if(ui32Attr & UDMA_ATTR_USEBURST)
    {
        HWREG(ui32Base + UDMA_O_CLEARBURST) = 1 << ui32ChannelNum;
    }

    // Clear the alternate control select bit for this channel, if set in
    // ululAttr.
    if(ui32Attr & UDMA_ATTR_ALTSELECT)
    {
        HWREG(ui32Base + UDMA_O_CLEARCHNLPRIALT) = 1 << ui32ChannelNum;
    }

    // Clear the high priority bit for this channel, if set in ui32Attr.
    if(ui32Attr & UDMA_ATTR_HIGH_PRIORITY)
    {
        HWREG(ui32Base + UDMA_O_CLEARCHNLPRIORITY) = 1 << ui32ChannelNum;
    }

    // Clear the request mask bit for this channel, if set in ui32Attr.
    if(ui32Attr & UDMA_ATTR_REQMASK)
    {
        HWREG(ui32Base + UDMA_O_CLEARREQMASK) = 1 << ui32ChannelNum;
    }
}

void uDMAChannelAttributeEnable	(	uint32_t	ui32Base,
		uint32_t	ui32ChannelNum,
		uint32_t	ui32Attr
	)

Enables attributes of a uDMA channel.

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

Parameters

ui32Base	is the base address of the uDMA port.
ui32ChannelNum	is the channel to configure.
ui32Attr	is a combination of attributes for the channel. The parameter is the bitwise OR of any of the following: UDMA_ATTR_USEBURST is used to restrict transfers to use only a 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

{
    // Check the arguments.
    ASSERT(uDMABaseValid(ui32Base));
    ASSERT(ui32ChannelNum < UDMA_NUM_CHANNELS);
    ASSERT((ui32Attr & ~(UDMA_ATTR_USEBURST | UDMA_ATTR_ALTSELECT |
                         UDMA_ATTR_HIGH_PRIORITY | UDMA_ATTR_REQMASK)) == 0);

    // Set the useburst bit for this channel if set in ui32Attr.
    if(ui32Attr & UDMA_ATTR_USEBURST)
    {
        HWREG(ui32Base + UDMA_O_SETBURST) = 1 << ui32ChannelNum;
    }

    // Set the alternate control select bit for this channel,
    // if set in ui32Attr.
    if(ui32Attr & UDMA_ATTR_ALTSELECT)
    {
        HWREG(ui32Base + UDMA_O_SETCHNLPRIALT) = 1 << ui32ChannelNum;
    }

    // Set the high priority bit for this channel, if set in ui32Attr.
    if(ui32Attr & UDMA_ATTR_HIGH_PRIORITY)
    {
        HWREG(ui32Base + UDMA_O_SETCHNLPRIORITY) = 1 << ui32ChannelNum;
    }

    // Set the request mask bit for this channel, if set in ui32Attr.
    if(ui32Attr & UDMA_ATTR_REQMASK)
    {
        HWREG(ui32Base + UDMA_O_SETREQMASK) = 1 << ui32ChannelNum;
    }
}

uint32_t uDMAChannelAttributeGet	(	uint32_t	ui32Base,
		uint32_t	ui32ChannelNum
	)

Gets the enabled attributes of a uDMA channel.

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

Parameters

ui32Base	is the base address of the uDMA port.
ui32ChannelNum	is the channel to configure.

Returns

Returns the bitwise 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 a 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.

{
    uint32_t ui32Attr = 0;

    // Check the arguments.
    ASSERT(uDMABaseValid(ui32Base));
    ASSERT(ui32ChannelNum < UDMA_NUM_CHANNELS);

    // Check to see if useburst bit is set for this channel.
    if(HWREG(ui32Base + UDMA_O_SETBURST) & (1 << ui32ChannelNum))
    {
        ui32Attr |= UDMA_ATTR_USEBURST;
    }

    // Check to see if the alternate control bit is set for this channel.
    if(HWREG(ui32Base + UDMA_O_SETCHNLPRIALT) & (1 << ui32ChannelNum))
    {
        ui32Attr |= UDMA_ATTR_ALTSELECT;
    }

    // Check to see if the high priority bit is set for this channel.
    if(HWREG(ui32Base + UDMA_O_SETCHNLPRIORITY) & (1 << ui32ChannelNum))
    {
        ui32Attr |= UDMA_ATTR_HIGH_PRIORITY;
    }

    // Check to see if the request mask bit is set for this channel.
    if(HWREG(ui32Base + UDMA_O_SETREQMASK) & (1 << ui32ChannelNum))
    {
        ui32Attr |= UDMA_ATTR_REQMASK;
    }

    // Return the configuration flags.
    return(ui32Attr);
}

void uDMAChannelControlSet	(	uint32_t	ui32Base,
		uint32_t	ui32ChannelStructIndex,
		uint32_t	ui32Control
	)

Sets the control parameters for a uDMA channel control structure.

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

Note

The address increment cannot be smaller than the data size.

Parameters

ui32Base	is the base address of the uDMA port.
ui32ChannelStructIndex	is the bitwise OR of the uDMA channel number and: UDMA_PRI_SELECT : Use primary data structure. UDMA_ALT_SELECT : Use alternate data structure.
ui32Control	is the bitwise OR of five values: Data size UDMA_SIZE_8 : 8 bits. UDMA_SIZE_16 : 16 bits. UDMA_SIZE_32 : 32 bits. Source address increment UDMA_SRC_INC_8 : 8 bits. UDMA_SRC_INC_16 : 16 bits. UDMA_SRC_INC_32 : 32 bits. UDMA_SRC_INC_NONE : Non-incrementing. Destination address increment UDMA_DST_INC_8 : 8 bits. UDMA_DST_INC_16 : 16 bits. UDMA_DST_INC_32 : 32 bits. UDMA_DST_INC_NONE : Non-incrementing. Arbitration size. Determines how many items are transferred before the uDMA controller re-arbitrates for the bus. In power of 2. UDMA_ARB_1 UDMA_ARB_2 UDMA_ARB_4 UDMA_ARB_8 ... UDMA_ARB_1024 Force the channel to only respond to burst requests at the tail end of a scatter-gather transfer. UDMA_NEXT_USEBURST

Returns

None

{
    tDMAControlTable *pControlTable;

    // Check the arguments.
    ASSERT(uDMABaseValid(ui32Base));
    ASSERT(ui32ChannelStructIndex < (UDMA_NUM_CHANNELS * 2));
    ASSERT(HWREG(ui32Base + UDMA_O_CTRL) != 0);

    // Get the base address of the control table.
    pControlTable = (tDMAControlTable *)HWREG(ui32Base + UDMA_O_CTRL);

    // Get the current control word value and mask off the fields to be
    // changed, then OR in the new settings.
    pControlTable[ui32ChannelStructIndex].ui32Control =
        ((pControlTable[ui32ChannelStructIndex].ui32Control &
          ~(UDMA_DST_INC_M |
            UDMA_SRC_INC_M |
            UDMA_SIZE_M |
            UDMA_ARB_M |
            UDMA_NEXT_USEBURST)) |
         ui32Control);
}

static void uDMAChannelDisable ( uint32_t  ui32Base, uint32_t  ui32ChannelNum  )

inlinestatic

Disables a uDMA channel for operation.

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

Parameters

ui32Base	is the base address of the uDMA port.
ui32ChannelNum	is the channel number to disable.

Returns

None.

{
    // Check the arguments.
    ASSERT(uDMABaseValid(ui32Base));
    ASSERT(ui32ChannelNum < UDMA_NUM_CHANNELS);

    // Set the bit for this channel in the enable clear register.
    HWREG(ui32Base + UDMA_O_CLEARCHANNELEN) = 1 << ui32ChannelNum;
}

static void uDMAChannelEnable ( uint32_t  ui32Base, uint32_t  ui32ChannelNum  )

inlinestatic

Enables a uDMA channel for operation.

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 will be automatically disabled by the uDMA controller. Therefore, this function should be called prior to starting up any new transfer.

Parameters

ui32Base	is the base address of the uDMA port.
ui32ChannelNum	is the channel number to enable.

Returns

None

{
    // Check the arguments.
    ASSERT(uDMABaseValid(ui32Base));
    ASSERT(ui32ChannelNum < UDMA_NUM_CHANNELS);

    // Set the bit for this channel in the enable set register.
    HWREG(ui32Base + UDMA_O_SETCHANNELEN) = 1 << ui32ChannelNum;
}

static bool uDMAChannelIsEnabled ( uint32_t  ui32Base, uint32_t  ui32ChannelNum  )

inlinestatic

Checks if a uDMA channel is enabled for operation.

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

Parameters

ui32Base	is the base address of the uDMA port.
ui32ChannelNum	is the channel number to check.

Returns

Returns status of uDMA channel.

• true : Channel is enabled.
• false : Disabled.

{
    // Check the arguments.
    ASSERT(uDMABaseValid(ui32Base));
    ASSERT(ui32ChannelNum < UDMA_NUM_CHANNELS);

    // AND the specified channel bit with the enable register, and return the
    // result.
    return((HWREG(ui32Base + UDMA_O_SETCHANNELEN) & (1 << ui32ChannelNum)) ?
           true : false);
}

uint32_t uDMAChannelModeGet	(	uint32_t	ui32Base,
		uint32_t	ui32ChannelStructIndex
	)

Gets the transfer mode for a uDMA channel control structure.

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

Parameters

ui32Base	is the base address of the uDMA port.
ui32ChannelStructIndex	is the bitwise OR of the uDMA channel number and: UDMA_PRI_SELECT UDMA_ALT_SELECT

Returns

Returns the transfer mode of the specified channel and control structure, which will be one of the following values:

• UDMA_MODE_STOP
• UDMA_MODE_BASIC
• UDMA_MODE_AUTO
• UDMA_MODE_PINGPONG
• UDMA_MODE_MEM_SCATTER_GATHER
• UDMA_MODE_PER_SCATTER_GATHER

{
    tDMAControlTable *pControlTable;
    uint32_t ui32Control;

    // Check the arguments.
    ASSERT(uDMABaseValid(ui32Base));
    ASSERT(ui32ChannelStructIndex < (UDMA_NUM_CHANNELS * 2));
    ASSERT(HWREG(ui32Base + UDMA_O_CTRL) != 0);

    // Get the base address of the control table.
    pControlTable = (tDMAControlTable *)HWREG(ui32Base + UDMA_O_CTRL);

    // Get the current control word value and mask off all but the mode field.
    ui32Control = (pControlTable[ui32ChannelStructIndex].ui32Control &
                   UDMA_MODE_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);
}

static void uDMAChannelPriorityClear ( uint32_t  ui32Base, uint32_t  ui32ChannelNum  )

inlinestatic

Clear the priority of a uDMA channel.

Note

Writing 0 to a bit has no effect on the priority. To set a channel priority to high use uDMAChannelPrioritySet().

Parameters

ui32Base	is the base address of the uDMA port.
ui32ChannelNum	The uDMA channel to clear the priority for.

Returns

None

{
    // Check the arguments.
    ASSERT(uDMABaseValid(ui32Base));
    ASSERT(ui32ChannelNum < UDMA_NUM_CHANNELS);

    // Clear the channel priority.
    HWREG(ui32Base + UDMA_O_CLEARCHNLPRIORITY) = 1 << ui32ChannelNum;
}

static bool uDMAChannelPriorityGet ( uint32_t  ui32Base, uint32_t  ui32ChannelNum  )

inlinestatic

Get the priority of a uDMA channel.

Parameters

ui32Base	is the base address of the uDMA port.
ui32ChannelNum	The uDMA channel to get the priority for.

Returns

Returns one of:

• UDMA_PRIORITY_HIGH
• UDMA_PRIORITY_LOW

{
    // Check the arguments.
    ASSERT(uDMABaseValid(ui32Base));
    ASSERT(ui32ChannelNum < UDMA_NUM_CHANNELS);

    // Return the channel priority.
    return(HWREG(ui32Base + UDMA_O_SETCHNLPRIORITY) & (1 << ui32ChannelNum) ?
           UDMA_PRIORITY_HIGH : UDMA_PRIORITY_LOW);
}

static void uDMAChannelPrioritySet ( uint32_t  ui32Base, uint32_t  ui32ChannelNum  )

inlinestatic

Set the priority of a uDMA channel.

Note

Writing 0 to a bit has no effect on the priority. To reset a channel priority to the default value use uDMAChannelPriorityClear().

Parameters

ui32Base	is the base address of the uDMA port.
ui32ChannelNum	is uDMA channel to set the priority for.

Returns

None

{
    // Check the arguments.
    ASSERT(uDMABaseValid(ui32Base));
    ASSERT(ui32ChannelNum < UDMA_NUM_CHANNELS);

    // Set the channel priority to high.
    HWREG(ui32Base + UDMA_O_SETCHNLPRIORITY) = 1 << ui32ChannelNum;
}

static void uDMAChannelRequest ( uint32_t  ui32Base, uint32_t  ui32ChannelNum  )

inlinestatic

Requests a uDMA channel to start a transfer.

This function allows software to request a uDMA channel to begin a transfer. This 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 a software channel and interrupts are used, then the completion will be signaled on the uDMA dedicated interrupt. If a peripheral channel is used, then the completion will be signaled on the peripheral's interrupt.

Parameters

ui32Base	is the base address of the uDMA port.
ui32ChannelNum	is the channel number on which to request a uDMA transfer.

Returns

None.

{
    // Check the arguments.
    ASSERT(uDMABaseValid(ui32Base));
    ASSERT(ui32ChannelNum < UDMA_NUM_CHANNELS);

    // Set the bit for this channel in the software uDMA request register.
    HWREG(ui32Base + UDMA_O_SOFTREQ) = 1 << ui32ChannelNum;
}

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

Configures a uDMA channel for scatter-gather mode.

This function is used to configure a channel for scatter-gather mode. The caller must have already set up a task list, and 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 the scatter-gather should be configured for a peripheral or memory scatter-gather operation.

Parameters

ui32Base	is the base address of the uDMA port.
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 will be memory scatter-gather transfer)

Returns

None

See also

uDMATaskStructEntry()

{
    tDMAControlTable *pControlTable;
    tDMAControlTable *pTaskTable;

    // Check the parameters.
    ASSERT(uDMABaseValid(ui32Base));
    ASSERT(ui32ChannelNum < UDMA_NUM_CHANNELS);
    ASSERT(HWREG(ui32Base + UDMA_O_CTRL) != 0);
    ASSERT(pvTaskList != 0);
    ASSERT(ui32TaskCount <= UDMA_XFER_SIZE_MAX);
    ASSERT(ui32TaskCount != 0);

    // Get the base address of the control table.
    pControlTable = (tDMAControlTable *)HWREG(ui32Base + UDMA_O_CTRL);

    // Get a handy pointer to the task list.
    pTaskTable = (tDMAControlTable *)pvTaskList;

    // Compute the ending address for the source pointer. This will be the
    // last element of the last task in the task table.
    pControlTable[ui32ChannelNum].pvSrcEndAddr =
        &pTaskTable[ui32TaskCount - 1].ui32Spare;

    // Compute the ending address for the destination pointer. This will be
    // the end of the alternate structure for this channel.
    pControlTable[ui32ChannelNum].pvDstEndAddr =
        &pControlTable[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).
    pControlTable[ui32ChannelNum].ui32Control =
        (UDMA_DST_INC_32 | UDMA_SRC_INC_32 |
         UDMA_SIZE_32 | UDMA_ARB_4 |
         (((ui32TaskCount * 4) - 1) << UDMA_XFER_SIZE_S) |
         (ui32IsPeriphSG ? UDMA_MODE_PER_SCATTER_GATHER :
          UDMA_MODE_MEM_SCATTER_GATHER));

    // 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(ui32Base + UDMA_O_CLEARCHNLPRIALT) = 1 << ui32ChannelNum;

}

uint32_t uDMAChannelSizeGet	(	uint32_t	ui32Base,
		uint32_t	ui32ChannelStructIndex
	)

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

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 will be returned. If the transfer is complete, then 0 will be returned.

Parameters

ui32Base	is the base address of the uDMA port.
ui32ChannelStructIndex	is the bitwise OR of the uDMA channel number and: UDMA_PRI_SELECT UDMA_ALT_SELECT

Returns

Returns the number of items remaining to transfer.

{
    tDMAControlTable *pControlTable;
    uint32_t ui32Control;

    // Check the arguments.
    ASSERT(uDMABaseValid(ui32Base));
    ASSERT(ui32ChannelStructIndex < (UDMA_NUM_CHANNELS * 2));
    ASSERT(HWREG(ui32Base + UDMA_O_CTRL) != 0);

    // Get the base address of the control table.
    pControlTable = (tDMAControlTable *)HWREG(ui32Base + UDMA_O_CTRL);

    // Get the current control word value and mask off all but the size field
    // and the mode field.
    ui32Control = (pControlTable[ui32ChannelStructIndex].ui32Control &
                   (UDMA_XFER_SIZE_M | UDMA_MODE_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 >> UDMA_XFER_SIZE_S) + 1);
    }
}

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

Sets the transfer parameters for a uDMA channel control structure.

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

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 will take care of this if the pointers are pointing to storage of the appropriate data type.

The two scatter/gather modes, MEMORY and PERIPHERAL, are actually different depending on whether the primary or alternate control structure is selected. This function will look for the UDMA_PRI_SELECT and UDMA_ALT_SELECT flag along with the channel number and will set 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 will not begin until the channel has been set up 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 will be 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 will return UDMA_MODE_STOP when a channel control structure is inactive and safe to modify.

Parameters

ui32Base	is the base address of the uDMA port.
ui32ChannelStructIndex	is the bitwise OR of the uDMA channel number and: UDMA_PRI_SELECT : Use primary data structure. UDMA_ALT_SELECT : Use alternate data structure.
ui32Mode	is the type of uDMA transfer. The 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 : Perform a basic transfer based on request. UDMA_MODE_AUTO to perform a transfer that will always complete once started even if request is removed. UDMA_MODE_PINGPONG : Set up a transfer that switches between the primary and alternate control structures for the channel. This allows use of ping-pong buffering for uDMA transfers. UDMA_MODE_MEM_SCATTER_GATHER : Set up a memory scatter-gather transfer. UDMA_MODE_PER_SCATTER_GATHER : Set up a peripheral scatter-gather 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 (NOT bytes).

Returns

None

{
    tDMAControlTable *pControlTable;
    uint32_t ui32Control;
    uint32_t ui32Inc;
    uint32_t ui32BufferBytes;

    // Check the arguments.
    ASSERT(uDMABaseValid(ui32Base));
    ASSERT(ui32ChannelStructIndex < (UDMA_NUM_CHANNELS * 2));
    ASSERT(HWREG(ui32Base + UDMA_O_CTRL) != 0);
    ASSERT(ui32Mode <= UDMA_MODE_PER_SCATTER_GATHER);
    ASSERT((uint32_t)pvSrcAddr >= SRAM_BASE);
    ASSERT((uint32_t)pvDstAddr >= SRAM_BASE);
    ASSERT((ui32TransferSize != 0) && (ui32TransferSize <= UDMA_XFER_SIZE_MAX));

    // Get the base address of the control table.
    pControlTable = (tDMAControlTable *)HWREG(ui32Base + UDMA_O_CTRL);

    // Get the current control word value and mask off the mode and size
    // fields.
    ui32Control = (pControlTable[ui32ChannelStructIndex].ui32Control &
                   ~(UDMA_XFER_SIZE_M | UDMA_MODE_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) << UDMA_XFER_SIZE_S);

    // Get the address increment value for the source, from the control word.
    ui32Inc = (ui32Control & UDMA_SRC_INC_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 >> UDMA_SRC_INC_S;
        ui32BufferBytes = ui32TransferSize << ui32Inc;
        pvSrcAddr = (void *)((uint32_t)pvSrcAddr + ui32BufferBytes - (1 << ui32Inc));
    }

    // Load the source ending address into the control block.
    pControlTable[ui32ChannelStructIndex].pvSrcEndAddr = pvSrcAddr;

    // Get the address increment value for the destination, from the control
    // word.
    ui32Inc = ui32Control & UDMA_DST_INC_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 needs to 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 *)&pControlTable[ui32ChannelStructIndex |
                                       UDMA_ALT_SELECT].ui32Spare;
        }
        // Not a scatter-gather transfer, calculate end pointer normally.
        else
        {
            ui32Inc = ui32Inc >> UDMA_DST_INC_S;
            ui32BufferBytes = ui32TransferSize << ui32Inc;
            pvDstAddr = (void *)((uint32_t)pvDstAddr + ui32BufferBytes - 1);
        }
    }

    // Load the destination ending address into the control block.
    pControlTable[ui32ChannelStructIndex].pvDstEndAddr = pvDstAddr;

    // Write the new control word value.
    pControlTable[ui32ChannelStructIndex].ui32Control = ui32Control;
}

static void* uDMAControlAlternateBaseGet ( uint32_t  ui32Base )

inlinestatic

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.

Parameters

ui32Base

is the base address of the uDMA port.

Returns

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

{
    // Check the arguments.
    ASSERT(uDMABaseValid(ui32Base));

    // Read the current value of the control base register, and return it to
    // the caller.
    return((void *)HWREG(ui32Base + UDMA_O_ALTCTRL));
}

static void* uDMAControlBaseGet ( uint32_t  ui32Base )

inlinestatic

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.

Parameters

ui32Base

is the base address of the uDMA port.

Returns

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

{
    // Check the arguments.

    ASSERT(uDMABaseValid(ui32Base));
    // Read the current value of the control base register, and return it to
    // the caller.
    return((void *)HWREG(ui32Base + UDMA_O_CTRL));
}

static void uDMAControlBaseSet ( uint32_t  ui32Base, void *  pControlTable  )

inlinestatic

Sets the base address for the channel control table.

This function sets 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 set before any of the channel functions can be used. Setting the base address of the primary control table will automatically set the address for the alternate control table as the next memory location after the primary control table.

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

Note

This register cannot be read when the controller is in the reset state.

Parameters

ui32Base	is the base address of the uDMA port.
pControlTable	is a pointer to the 1024 byte aligned base address of the uDMA channel control table. The address must be an absolute address in system memory space.

Returns

None

{
    // Check the arguments.
    ASSERT(uDMABaseValid(ui32Base));
    ASSERT(((uint32_t)pControlTable & ~0x3FF) ==
           (uint32_t)pControlTable);
    ASSERT((uint32_t)pControlTable >= SRAM_BASE);

    // Program the base address into the register.
    HWREG(ui32Base + UDMA_O_CTRL) = (uint32_t)pControlTable;
}

static void uDMADisable ( uint32_t  ui32Base )

inlinestatic

Disables the uDMA controller for use.

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

Parameters

ui32Base

is the base address of the uDMA port.

Returns

None.

{
    // Check the arguments.
    ASSERT(uDMABaseValid(ui32Base));

    // Clear the master enable bit in the config register.
    HWREG(ui32Base + UDMA_O_CFG) = 0;
}

static void uDMAEnable ( uint32_t  ui32Base )

inlinestatic

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.

Parameters

ui32Base

is the base address of the uDMA port.

Returns

None

{
    // Check the arguments.
    ASSERT(uDMABaseValid(ui32Base));

    // Set the master enable bit in the config register.
    HWREG(ui32Base + UDMA_O_CFG) = UDMA_CFG_MASTERENABLE;
}

static void uDMAErrorStatusClear ( uint32_t  ui32Base )

inlinestatic

Clears the uDMA error interrupt.

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

Parameters

ui32Base

is the base address of the uDMA port.

Returns

None

{
    // Check the arguments.
    ASSERT(uDMABaseValid(ui32Base));

    // Clear the uDMA error interrupt.
    HWREG(ui32Base + UDMA_O_ERROR) = UDMA_ERROR_STATUS;
}

static uint32_t uDMAErrorStatusGet ( uint32_t  ui32Base )

inlinestatic

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.

Parameters

ui32Base

is the base address of the uDMA port.

Returns

Returns non-zero if a uDMA error is pending.

{
    // Check the arguments.
    ASSERT(uDMABaseValid(ui32Base));

    // Return the uDMA error status.
    return(HWREG(ui32Base + UDMA_O_ERROR));
}

static uint32_t uDMAGetStatus ( uint32_t  ui32Base )

inlinestatic

Return the status of the uDMA module.

Note

This status register cannot be read when the controller is in the reset state.

Parameters

ui32Base

is the base address of the uDMA port.

Returns

Current status of the uDMA module.

{
    // Check the arguments.
    ASSERT(uDMABaseValid(ui32Base));

    // Read and return the status register.
    return HWREG(ui32Base + UDMA_O_STATUS);
}

static void uDMAIntClear ( uint32_t  ui32Base, uint32_t  ui32ChanMask  )

inlinestatic

Clears uDMA interrupt done status.

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 will be cleared (if it was set).

Parameters

ui32Base	is the base address of the uDMA port.
ui32ChanMask	is a 32-bit mask with one bit for each uDMA channel.

Returns

None

{
    // Check the arguments.
    ASSERT(uDMABaseValid(ui32Base));

    // Clear the requested bits in the uDMA interrupt status register.
    HWREG(ui32Base + UDMA_O_REQDONE) = ui32ChanMask;
}

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

inlinestatic

Registers an interrupt handler for the uDMA controller in the dynamic interrupt table.

Note

Only use this function if you want to use the dynamic vector table (in SRAM)!

This function registers a function as the interrupt handler for a specific interrupt and enables the corresponding interrupt in the interrupt controller.

Note

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

Parameters

ui32Base	is the base address of the uDMA module.
ui32IntChannel	specifies which uDMA interrupt is to be registered. INT_DMA_DONE_COMB : Register an interrupt handler to process interrupts from the uDMA software channel. INT_DMA_ERR : Register an interrupt handler to process uDMA error interrupts.
pfnHandler	is a pointer to the function to be called when the interrupt is activated.

Returns

None

See also

IntRegister() for important information about registering interrupt handlers.

{
    // Check the arguments.
    ASSERT(uDMABaseValid(ui32Base));
    ASSERT(pfnHandler);
    ASSERT((ui32IntChannel == INT_DMA_DONE_COMB) || (ui32IntChannel == INT_DMA_ERR));

    // Register the interrupt handler.
    IntRegister(ui32IntChannel, pfnHandler);

    // Enable the memory management fault.
    IntEnable(ui32IntChannel);
}

Here is the call graph for this function:

static uint32_t uDMAIntStatus ( uint32_t  ui32Base )

inlinestatic

Get the uDMA interrupt status.

This function returns the interrupt status for the specified UDMA. This function does not differentiate between software or hardware activated interrupts.

Parameters

ui32Base

is the base address of the uDMA port.

Returns

None

{
    // Check the arguments.
    ASSERT(uDMABaseValid(ui32Base));

    // Return the uDMA interrupt status register.
    return (HWREG(ui32Base + UDMA_O_REQDONE));
}

static void uDMAIntSwEventDisable ( uint32_t  ui32Base, uint32_t  ui32IntChannel  )

inlinestatic

Disable interrupt on software event driven uDMA transfers.

This register disables the blocking of the uDMA status signals propagation to the hardware peripheral connected to the uDMA on the ui32IntChannel.

Parameters

ui32Base	is the base address of the uDMA port.
ui32IntChannel	identifies which uDMA interrupt to disable software interrupts for.

Returns

None

See also

uDMAIntSwEventEnable()

{
    // Check the arguments.
    ASSERT(uDMABaseValid(ui32Base));
    ASSERT(ui32IntChannel < UDMA_NUM_CHANNELS);

    // Disable the SW channel.
    HWREGBITW(ui32Base + UDMA_O_DONEMASK, ui32IntChannel) = 0;
}

static void uDMAIntSwEventEnable ( uint32_t  ui32Base, uint32_t  ui32IntChannel  )

inlinestatic

Enable interrupt on software event driven uDMA transfers.

Note

The main purpose of this function is to prevent propagation of uDMA status signals to a peripheral, if a peripheral and a software event is sharing the uDMA channel. If it is desired to initiate a transfer by writing to a register inside the uDMA (this means a software driven channel), then the uDMA status signals propagation need to be blocked to the hardware peripherals.

Parameters

ui32Base	is the base address of the uDMA port.
ui32IntChannel	identifies which uDMA interrupt to enable software interrupts for.

Returns

None

{
    // Check the arguments.
    ASSERT(uDMABaseValid(ui32Base));
    ASSERT(ui32IntChannel < UDMA_NUM_CHANNELS);

    // Enable the channel.
    HWREGBITW(ui32Base + UDMA_O_DONEMASK, ui32IntChannel) = 1;
}

static void uDMAIntUnregister ( uint32_t  ui32Base, uint32_t  ui32IntChannel  )

inlinestatic

Unregisters an interrupt handler for the uDMA controller in the dynamic interrupt table.

This function will disable and clear the handler to be called for the specified uDMA interrupt.

Parameters

ui32Base	is the base address of the uDMA module.
ui32IntChannel	specifies which uDMA interrupt to unregister. INT_DMA_DONE_COMB : Register an interrupt handler to process interrupts from the uDMA software channel. INT_DMA_ERR : Register an interrupt handler to process uDMA error interrupts.

Returns

None

See also

IntRegister() for important information about registering interrupt handlers.

{
    // Check the arguments.
    ASSERT(uDMABaseValid(ui32Base));
    ASSERT((ui32IntChannel == INT_DMA_DONE_COMB) || (ui32IntChannel == INT_DMA_ERR));

    // Disable the interrupt.
    IntDisable(ui32IntChannel);

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

Here is the call graph for this function:

Macro Definition Documentation

#define UDMA_ALT_SELECT   0x00000020

Referenced by uDMAChannelScatterGatherSet(), and uDMAChannelTransferSet().

#define UDMA_ARB_1   0x00000000

#define UDMA_ARB_1024   0x00028000

#define UDMA_ARB_128   0x0001c000

#define UDMA_ARB_16   0x00010000

#define UDMA_ARB_2   0x00004000

#define UDMA_ARB_256   0x00020000

#define UDMA_ARB_32   0x00014000

#define UDMA_ARB_4   0x00008000

Referenced by uDMAChannelScatterGatherSet().

#define UDMA_ARB_512   0x00024000

#define UDMA_ARB_64   0x00018000

#define UDMA_ARB_8   0x0000c000

#define UDMA_ARB_M   0x0003C000

Referenced by uDMAChannelControlSet().

#define UDMA_ARB_S   14

#define UDMA_ATTR_ALL   0x0000000F

#define UDMA_ATTR_ALTSELECT   0x00000002

Referenced by uDMAChannelAttributeDisable(), uDMAChannelAttributeEnable(), and uDMAChannelAttributeGet().

#define UDMA_ATTR_HIGH_PRIORITY   0x00000004

Referenced by uDMAChannelAttributeDisable(), uDMAChannelAttributeEnable(), and uDMAChannelAttributeGet().

#define UDMA_ATTR_REQMASK   0x00000008

Referenced by uDMAChannelAttributeDisable(), uDMAChannelAttributeEnable(), and uDMAChannelAttributeGet().

#define UDMA_ATTR_USEBURST   0x00000001

Referenced by uDMAChannelAttributeDisable(), uDMAChannelAttributeEnable(), and uDMAChannelAttributeGet().

#define UDMA_CHAN_AON_PROG2   13

#define UDMA_CHAN_AON_RTC   15

#define UDMA_CHAN_AUX_ADC   7

#define UDMA_CHAN_AUX_SW   8

#define UDMA_CHAN_DMA_PROG   14

#define UDMA_CHAN_SSI0_RX   3

#define UDMA_CHAN_SSI0_TX   4

#define UDMA_CHAN_SSI1_RX   16

#define UDMA_CHAN_SSI1_TX   17

#define UDMA_CHAN_SW_EVT0   0

#define UDMA_CHAN_SW_EVT1   18

#define UDMA_CHAN_SW_EVT2   19

#define UDMA_CHAN_SW_EVT3   20

#define UDMA_CHAN_TIMER0_A   9

#define UDMA_CHAN_TIMER0_B   10

#define UDMA_CHAN_TIMER1_A   11

#define UDMA_CHAN_TIMER1_B   12

#define UDMA_CHAN_UART0_RX   1

#define UDMA_CHAN_UART0_TX   2

#define UDMA_DST_INC_16   0x40000000

#define UDMA_DST_INC_32   0x80000000

Referenced by uDMAChannelScatterGatherSet().

#define UDMA_DST_INC_8   0x00000000

#define UDMA_DST_INC_M   0xC0000000

Referenced by uDMAChannelControlSet(), and uDMAChannelTransferSet().

#define UDMA_DST_INC_NONE   0xC0000000

Referenced by uDMAChannelTransferSet().

#define UDMA_DST_INC_S   30

Referenced by uDMAChannelTransferSet().

#define UDMA_MODE_ALT_SELECT   0x00000001

Referenced by uDMAChannelModeGet(), and uDMAChannelTransferSet().

#define UDMA_MODE_AUTO   0x00000002

#define UDMA_MODE_BASIC   0x00000001

#define UDMA_MODE_M   0x00000007

Referenced by uDMAChannelModeGet(), uDMAChannelSizeGet(), and uDMAChannelTransferSet().

#define UDMA_MODE_MEM_SCATTER_GATHER   0x00000004

Referenced by uDMAChannelModeGet(), uDMAChannelScatterGatherSet(), and uDMAChannelTransferSet().

#define UDMA_MODE_PER_SCATTER_GATHER   0x00000006

Referenced by uDMAChannelModeGet(), uDMAChannelScatterGatherSet(), and uDMAChannelTransferSet().

#define UDMA_MODE_PINGPONG   0x00000003

#define UDMA_MODE_STOP   0x00000000

#define UDMA_NEXT_USEBURST   0x00000008

Referenced by uDMAChannelControlSet().

#define UDMA_NUM_CHANNELS   21

Referenced by uDMAChannelAttributeDisable(), uDMAChannelAttributeEnable(), uDMAChannelAttributeGet(), uDMAChannelControlSet(), uDMAChannelDisable(), uDMAChannelEnable(), uDMAChannelIsEnabled(), uDMAChannelModeGet(), uDMAChannelPriorityClear(), uDMAChannelPriorityGet(), uDMAChannelPrioritySet(), uDMAChannelRequest(), uDMAChannelScatterGatherSet(), uDMAChannelSizeGet(), uDMAChannelTransferSet(), uDMAIntSwEventDisable(), and uDMAIntSwEventEnable().

#define UDMA_PRI_SELECT   0x00000000

#define UDMA_PRIORITY_HIGH   0x00000001

Referenced by uDMAChannelPriorityGet().

#define UDMA_PRIORITY_LOW   0x00000000

Referenced by uDMAChannelPriorityGet().

#define UDMA_SIZE_16   0x11000000

#define UDMA_SIZE_32   0x22000000

Referenced by uDMAChannelScatterGatherSet().

#define UDMA_SIZE_8   0x00000000

#define UDMA_SIZE_M   0x33000000

Referenced by uDMAChannelControlSet().

#define UDMA_SIZE_S   24

#define UDMA_SRC_INC_16   0x04000000

#define UDMA_SRC_INC_32   0x08000000

Referenced by uDMAChannelScatterGatherSet().

#define UDMA_SRC_INC_8   0x00000000

#define UDMA_SRC_INC_M   0x0C000000

Referenced by uDMAChannelControlSet(), and uDMAChannelTransferSet().

#define UDMA_SRC_INC_NONE   0x0c000000

Referenced by uDMAChannelTransferSet().

#define UDMA_SRC_INC_S   26

Referenced by uDMAChannelTransferSet().

#define UDMA_XFER_SIZE_M   0x00003FF0

Referenced by uDMAChannelSizeGet(), and uDMAChannelTransferSet().

#define UDMA_XFER_SIZE_MAX   1024

Referenced by uDMAChannelScatterGatherSet(), and uDMAChannelTransferSet().

#define UDMA_XFER_SIZE_S   4

Referenced by uDMAChannelScatterGatherSet(), uDMAChannelSizeGet(), and uDMAChannelTransferSet().

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

Value:

{                                                                         \
        (((ui32SrcIncrement) == UDMA_SRC_INC_NONE) ? (pvSrcAddr) :            \
            ((void *)(&((uint8_t *)(pvSrcAddr))[((ui32TransferCount) <<       \
                                         ((ui32SrcIncrement) >> 26)) - 1]))), \
        (((ui32DstIncrement) == UDMA_DST_INC_NONE) ? (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.

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.

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

Parameters

ui32TransferCount	is the count of items to transfer for this task. It must be in the range 1-1024.
ui32ItemSize	is the bit size of the items to transfer for this task. It must be one of: UDMA_SIZE_8 UDMA_SIZE_16 UDMA_SIZE_32
ui32SrcIncrement	is the bit size increment for source data. It must be one of: UDMA_SRC_INC_8 UDMA_SRC_INC_16 UDMA_SRC_INC_32 UDMA_SRC_INC_NONE
pvSrcAddr	is the starting address of the data to transfer.
ui32DstIncrement	is the bit size increment for destination data. It must be one of: UDMA_DST_INC_8 UDMA_DST_INC_16 UDMA_DST_INC_32 UDMA_DST_INC_NONE
pvDstAddr	is the starting address of the destination data.
ui32ArbSize	is the arbitration size to use for the transfer task. This is used to select the arbitration size in powers of 2, from 1 to 1024. It must be one of: UDMA_ARB_1 UDMA_ARB_2 UDMA_ARB_4 ... UDMA_ARB_1024
ui32Mode	is the transfer mode for this task. 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. It must be one of: UDMA_MODE_BASIC UDMA_MODE_AUTO UDMA_MODE_MEM_SCATTER_GATHER UDMA_MODE_PER_SCATTER_GATHER

Returns

None (this is not a function)