#include <edma.h>

EDMA_REG *SC6xEDMA_Claim(SC6xEDMA *EdmaI,

                         int n,

                         SC6xEDMAChannel **c);

stand-alone

This function attempts to allocate EDMA channel number n from the kernel’s pool of free channels. If it succeeds, it returns a pointer to the requested channel’s hardware control registers. If it fails, it returns NULL.

#include <edma.h>

EDMA_REG *SC6xEDMA_ClaimWait(SC6xEDMA *EdmaI,

                             int n,

                             SC6xEDMAChannel **c);

stand-alone

This function attempts to allocate EDMA channel number n from the kernel’s pool of free channels. If the requested channel is unavailable, the calling thread is suspended until it does become available, if ever. Therefore this function never fails simply because the requested channel is not available. When it succeeds, it returns a pointer to the requested channel’s hardware control registers. If it fails for some other reason, it returns NULL.

The arguments are the same as for SC6xEDMA_Claim above.

#include <edma.h>

EDMA_REG *SC6xEDMA_ClaimAny(SC6xEDMA *EdmaI,

                            int oper,

                            SC6xEDMAChannel **c);

stand-alone

This function is similar to SC6xEDMA_Claim, except that instead of requesting a particular channel number, the call returns a pointer to any EDMA channel that happens to be free. You can get the number of the channel, which may be needed to deal with interrupts, from the result by means of the macro EDMA_INDEX. If no channel is presently free, or if the call fails for some other reason, it returns NULL.

#include <edma.h>

EDMA_REG *SC6xEDMA_ClaimAnyWait(SC6xEDMA *EdmaI,

                                int oper,

                                SC6xEDMAChannel **c);

stand-alone

This function is similar to SC6xEDMA_ClaimAny, except that if no channel is presently free, the calling thread is suspended (indefinitely) until a channel does become free. Therefore this function never fails simply because a channel is not available. When it succeeds, it returns a pointer to the allocated channel’s hardware control registers. If it fails for some other reason, it returns NULL.

The arguments are the same as for SC6xEDMA_ClaimAny above.

#include <edma.h>

void SC6xEDMA_FlushCache(SC6xEDMA *EdmaI,

                         unsigned int Modify,

                         unsigned int Bytes,

                         volatile void *Memory);

stand-alone

This function is provided to control the cache when using EDMA. The C6000 cache on processors with EDMA is unable to maintain coherence with external memory when both the CPU and an EDMA channel access the memory. This means, for example, that it is possible for a CPU read of external memory to be satisfied with wrong data from the cache even though an EDMA operation has written new values directly to that memory.

The function flushes any data in the cache corresponding to the external memory area defined by Bytes and Memory. If Modify is non-zero, the cache data is also invalidated.

The function does nothing if internal memory is specified or if the memory is in a non-cached region (the relevant MAR registers are 0).

To work round the hardware limitation it is necessary to manipulate the cache explicitly each time you perform an EDMA transfer involving external memory. You should stick to the following guidelines for each EDMA transfer:

This function can be quite slow asthe C6000 hardware requires polling to detect completion of the cache operation.

#include <edma.h>

EDMA_REG *SC6xEDMA_ClaimParam(SC6xEDMA *EdmaI,

                              unsigned int Which);

stand-alone

The parameters for EDMA operations are held in blocks of registers. This function returns a pointer to one such block. The parameter Which determines selects the block you want. If Which is 0, the function returns a pointer to the first free block it finds, otherwise the value (in the range 16 ≤Which ≤ 84) is used to select a particular block. Parameter block 85 is reserved for use as a terminating null block (see EDMA_NULL_PARAM).

The function returns a NULL pointer if a suitable parameter block cannot be claimed.

#include <edma.h>

void SC6xEDMA_ReleaseParam(SC6xEDMA *EdmaI,

                           EDMA_REG *Param);

stand-alone

Release a parameter block for reuse. The block, Param, must have been claimed previously using SC6xEDMA_ClaimParam.

#include <edma.h>

unsigned int EDMA_INDEX(EDMA_REG *P);

stand-alone

This macro converts a pointer to a parameter block into the index number of the associated EDMA channel. It is only meaningful for the first 64 entries in the parameter table. It is usually used in conjunction with SC6xEDMA_ClaimAny and SC6xEDMA_ClaimAnyWait to determine which EDMA channel has been claimed.

#include <edma.h>

unsigned int EDMA_LINK_OFFSET(EDMA_REG *P);

stand-alone

This macro converts a pointer to a parameter block into an offset from the start of the parameter area. This offset is required in the link field of one parameter block to chain it to the next.

#include <edma.h>

EDMA_REG *EDMA_EVENT_PARAM(int n);

stand-alone

This macro converts a parameter number (in the range 0 ≤ n ≤ 85) into a pointer to the corresponding parameter block.

#include <edma.h>

EDMA_REG *EDMA_NULL_PARAM;

stand-alone

This macro returns a pointer to the reserved parameter block that has been initialised to zeros. You use it to terminate a chain of transfer requests.