Functions | Defines | Data Structures | Typedefs | Enumerations | Variables

ECPY (C64P)

Functions

Void ECPY_configure (ECPY_Handle handle, ECPY_Params *restrict params, short transferNo)
 Configures the DMA transfer settings for the transfer=transferNo of the logical channel. Except for transferNo==1, the physical EDMA3 PaRAM associated with the transfer is modified. For transferNo==1 a "shadow" of the PaRAM registers gets configured, so that the configuration of 1st transfer remains persistent following ECPY_startEdma() calls.
Void ECPY_directConfigure (ECPY_Handle handle, ECPY_Params *restrict params, short transferNo)
 Configure the DMA transfer settings of handle's 'transferNo' transfer. This function always directly configures the physical EDMA3 PaRAM associated with the transfer. Since no shadow is used for the 1st transfer, the configuration settings of the 1st transfer gets lost following linked transfers or when the 1st transfer is a 3D transfer (numFrames > 1).
Void ECPY_configure16 (ECPY_Handle handle, ECPY_ParamField16b fieldId, unsigned short value, short transferNo)
 Modify the 16-bit DMA transfer parameter, indicated by the parameter field id, fieldId, of the current channel settings.
Void ECPY_directConfigure16 (ECPY_Handle handle, ECPY_ParamField16b fieldId, unsigned short value, short transferNo)
 Modify the 16-bit DMA transfer parameter, indicated by the parameter field id, fieldId, of the current channel settings. This function always directly configures the physical EDMA3 PaRAM's 16-bit half of the 32-bit registered associated with the transfer & field . No shadow is used.
Void ECPY_configure32 (ECPY_Handle handle, ECPY_ParamField32b fieldId, unsigned int value, short transferNo)
 Modify the 32-bit DMA transfer parameter, indicated by the parameter field id, fieldId, of the current channel settings.
Void ECPY_directConfigure32 (ECPY_Handle handle, ECPY_ParamField32b fieldId, unsigned int value, short transferNo)
 Modify the 32-bit DMA transfer parameter, indicated by the parameter field id, fieldId, of the current channel settings.
Void ECPY_setFinal (ECPY_Handle handle, short transferNo)
 Indicate that a given transfer will be the last in a sequence of linked transfers.
Void ECPY_directSetFinal (ECPY_Handle handle, short transferNo)
 Indicate that a given transfer will be the last in a sequence of linked transfers.
Void ECPY_setDestinationMemoryMode (ECPY_Handle handle, short mode)
 Indicate the memory space that DMA transfers submitted to the channel associated with the handle will modify. This information can be used for channel to TC Queue mapping for avoiding known Silicon GEM lockup issues or for performance improvements.
Void ECPY_start (ECPY_Handle handle)
 Submit a single or linked transfer using the most recently configured transfer parameter settings.
Void ECPY_directStartEdma (ECPY_Handle handle)
 Submit a single or linked transfer using the most recently 'direct' configured transfer parameter settings.
Void ECPY_directStartQdma (ECPY_Handle handle)
 ECPY_directStartQdma has not been implemented.
Void ECPY_wait (ECPY_Handle handle)
 Wait for all data transfers on a logical channel to complete.
Void ECPY_directWait (ECPY_Handle handle)
 Wait for all EDMA data transfers submitted to the logical channel via ECPY_directStartEdma to complete.
Void ECPY_activate (ECPY_Handle handle)
 Activate the given channel.
ECPY_Handle ECPY_createHandle (IRES_EDMA3CHAN2_Handle handle, IALG_Handle alg)
 Create an ECPY Handle using the supplied IRES_EDMA3CHAN handle.
Void ECPY_deleteHandle (ECPY_Handle handle)
 Delete ECPY_Handle.
Void ECPY_deactivate (ECPY_Handle handle)
 Deactivates the given channel.
Void ECPY_setEarlyCompletionMode (ECPY_Handle handle, short enabled)
 Setting the TCCMODE (Early or Normal) affects only the 'intermediate transfers' of the linked transfers submitted using this channel. All subsequent direct and non-direct ECPY_configure* calls using this ecpyHandle will program the OPT's TCCMODE to select Early or Normal completion mode based on the 'enabled' argument.
Void ECPY_init (Void)
 Initialize the ECPY module. Called by framework.
Void ECPY_exit (Void)
 Finalization of the ECPY module.

Defines

#define ti_sdo_fc_ires_NOPROTOCOLREV
#define ECPY_GTNAME   "ti.sdo.fc.ecpy"
#define ECPY_MODNAME   "ti.sdo.fc.ecpy"
 Name to pass to Diags_setMask() to enable logging for ECPY functions. For example, Diags_setMask(ECPY_MODNAME"+EX1234567"); turns on all Log statements in this module. Diags_setMask() must be called after initialization to take effect.

Data Structures

struct  ECPY_Params
 DMA transfer specific parameters. Defines the configuration of a logical channel. More...
struct  ECPY_CfgParams
 The module configuration structure for ECPY. It is set at design time by the system integrator to register customize memory allocation/free implementations. More...

Typedefs

typedef enum ECPY_ParamField16b ECPY_ParamField16b
 ECPY 16-bit param field structure. These values are passed to ECPY_configure16() to indicate the field of the ECPY_Params structure to be changed.
typedef enum ECPY_ParamField32b ECPY_ParamField32b
 ECPY 32-bit param field structure. These values are passed to ECPY_configure32() to indicate the field of the ECPY_Params structure to be changed.
typedef enum ECPY_TransferType ECPY_TransferType
 ECPY DMA Transfer Types:
typedef struct ECPY_Obj * ECPY_Handle
 Handle to "logical" ECPY Channel.
typedef struct ECPY_Params ECPY_Params
 DMA transfer specific parameters. Defines the configuration of a logical channel.
typedef Bool( ECPY_PersistentAllocFxn )(IALG_MemRec *memTab, Int numRecs)
 Memory allocation function signature for module configuration.
typedef Void( ECPY_PersistentFreeFxn )(IALG_MemRec *memTab, Int numRecs)
 Memory deallocation function signature for module configuration.
typedef Bool( ECPY_ScratchAllocFxn )(IALG_Handle alg, Int scratchId, IALG_MemRec *memTab, Int numRecs)
 Scratch Memory allocation function for all shared scratch ECPY handle state.
typedef Void( ECPY_ScratchFreeFxn )(Int mutexId, Void *addr, UInt size)
 Scratch Memory free function for all scratch allocated memory in ECPY Handle.
typedef Int( ECPY_getScratchIdFxn )(IALG_Handle alg)
 Function, when supplied, returns the scratchId associated with the algorithm instance whose handle is passed.
typedef struct ECPY_CfgParams ECPY_CfgParams
 The module configuration structure for ECPY. It is set at design time by the system integrator to register customize memory allocation/free implementations.

Enumerations

enum  ECPY_ParamField16b {
  ECPY_PARAMFIELD_ELEMENTSIZE = 8,
  ECPY_PARAMFIELD_NUMELEMENTS = 10,
  ECPY_PARAMFIELD_ELEMENTINDEX_SRC = 16,
  ECPY_PARAMFIELD_ELEMENTINDEX_DST = 18,
  ECPY_PARAMFIELD_FRAMEINDEX_SRC = 24,
  ECPY_PARAMFIELD_FRAMEINDEX_DST = 26,
  ECPY_PARAMFIELD_NUMFRAMES = 28
}
 

ECPY 16-bit param field structure. These values are passed to ECPY_configure16() to indicate the field of the ECPY_Params structure to be changed.

More...
enum  ECPY_ParamField32b {
  ECPY_PARAMFIELD_SRCADDR = 4,
  ECPY_PARAMFIELD_DSTADDR = 12,
  ECPY_PARAMFIELD_ELEMENTINDEXES = 16,
  ECPY_PARAMFIELD_FRAMEINDEXES = 24
}
 

ECPY 32-bit param field structure. These values are passed to ECPY_configure32() to indicate the field of the ECPY_Params structure to be changed.

More...
enum  ECPY_TransferType {
  ECPY_1D1D,
  ECPY_1D2D,
  ECPY_2D1D,
  ECPY_2D2D
}
 

ECPY DMA Transfer Types:

More...

Variables

__FAR__ ECPY_CfgParams ECPY_CFG_PARAMS
 Initialization parameters for the ECPY module.

Detailed Description

The ECPY module provides a comprehensive list of DMA operations applications or algorithms can perform on logical DMA channels it acquires through the IRES_EDMA3CHAN protocol. Example of ECPY operations include channel configuration, DMA transfer scheduling, and DMA transfer synchronization.

Remarks:
For additional information, please refer to the "Using DMA with Framework Components for 'C64x+" document.

Function Documentation

Void ECPY_configure ( ECPY_Handle  handle,
ECPY_Params *restrict  params,
short  transferNo 
)

Configures the DMA transfer settings for the transfer=transferNo of the logical channel. Except for transferNo==1, the physical EDMA3 PaRAM associated with the transfer is modified. For transferNo==1 a "shadow" of the PaRAM registers gets configured, so that the configuration of 1st transfer remains persistent following ECPY_startEdma() calls.

Parameters:
[in]handleECPY channel handle.
[in]paramsDMA transfer specific parameters used to configure this logical DMA channel.
[in]transferNoIndicates the individual transfer to be configured using the passed 'params'
Precondition:
channel must be in active state
valid ECPY_Handle handle
1 <= transferNo <= originally requested number of transfers
Postcondition:
Intermediate transfers are programmed with TCCMODE set to Early (default mode when channel is created ) or Normal Completion depending on the most recently configured Transfer Completion mode.
Void ECPY_directConfigure ( ECPY_Handle  handle,
ECPY_Params *restrict  params,
short  transferNo 
)

Configure the DMA transfer settings of handle's 'transferNo' transfer. This function always directly configures the physical EDMA3 PaRAM associated with the transfer. Since no shadow is used for the 1st transfer, the configuration settings of the 1st transfer gets lost following linked transfers or when the 1st transfer is a 3D transfer (numFrames > 1).

Parameters:
[in]handleECPY channel handle.
[in]paramsDMA transfer specific parameters used to configure this logical DMA channel.
[in]transferNoIndicates the individual transfer to be configured using the passed 'params'
Precondition:
channel must be in active state
valid ECPY_Handle handle
1 <= transferNo <= originally requested number of transfers
Postcondition:
Intermediate transfers are programmed with TCCMODE set to Early (default mode when channel is created ) or Normal Completion depending on the most recently configured Transfer Completion mode.
Void ECPY_configure16 ( ECPY_Handle  handle,
ECPY_ParamField16b  fieldId,
unsigned short  value,
short  transferNo 
)

Modify the 16-bit DMA transfer parameter, indicated by the parameter field id, fieldId, of the current channel settings.

Parameters:
[in]handleIRES_EDMA3CHAN channel handle.
[in]fieldIdIndicates which of the parameters is to be modified.
[in]valueNew value of the parameter to be modified.
[in]transferNoIndicates which transfer the parameters correspond to (same value that would be passed to ECPY_configure()).
Precondition:
Algorithm instance must be in "active" state using IALG interface.
Channel must be in "active" state.
ECPY_configure() must have previously been called at least once since channel activation.
1 <= transferNo <= originally requested number of transfers
Remarks:
Both an inlined version and a non-inlined version of this function are supported. To use the inlined version, add the line #define ECPY_CONFIGURE16_INLINE or #define ECPY_INLINE_ALL to the source file where this function is used. The #define must go above the line, #include <ecpy.h>. By default, this function will not be inlined. Another alternative is to define the macro in the build option of the file or of the project file.
Once a channel has been configured once with ECPY_configure(), ECPY_configure16() can be used to update any of the 16-bit parameter fields, for example, the number of elements in a frame to be transferred.
Void ECPY_directConfigure16 ( ECPY_Handle  handle,
ECPY_ParamField16b  fieldId,
unsigned short  value,
short  transferNo 
)

Modify the 16-bit DMA transfer parameter, indicated by the parameter field id, fieldId, of the current channel settings. This function always directly configures the physical EDMA3 PaRAM's 16-bit half of the 32-bit registered associated with the transfer & field . No shadow is used.

Parameters:
[in]handleIRES_EDMA3CHAN channel handle.
[in]fieldIdIndicates which of the parameters is to be modified.
[in]valueNew value of the parameter to be modified.
[in]transferNoIndicates which transfer the parameters correspond to (same value that would be passed to ECPY_directConfigure()).
Precondition:
Algorithm instance must be in "active" state using IALG interface.
Channel must be in "active" state.
ECPY_directConfigure() must have been called at least once since channel activation.
1 <= transferNo <= originally requested number of transfers
Remarks:
Both an inlined version and a non-inlined version of this function are supported. To use the inlined version, add the line #define ECPY_CONFIGURE16_INLINE or #define ECPY_INLINE_ALL to the source file where this function is used. The #define must go above the line, #include <ecpy.h>. By default, this function will not be inlined. Another alternative is to define the macro in the build option of the file or of the project file.
Once a channel has been configured once with ECPY_directConfigure(), ECPY_directConfigure16() can be used to update any of the 16-bit parameter fields, for example, the number of elements in a frame to be transferred.
Void ECPY_configure32 ( ECPY_Handle  handle,
ECPY_ParamField32b  fieldId,
unsigned int  value,
short  transferNo 
)

Modify the 32-bit DMA transfer parameter, indicated by the parameter field id, fieldId, of the current channel settings.

Parameters:
[in]handleECPY channel handle.
[in]fieldIdIndicates which of the parameters is to be modified.
[in]valueNew value of the parameter to be modified.
[in]transferNoIndicates which transfer the parameters correspond to (same value that would be passed to ECPY_configure()).
Precondition:
handle must be a valid channel handle.
Algorithm instance must be in "active" state using IALG interface.
Channel must be in 'active' state.
ECPY_configure() must have previously been called at least once since channel activation.
1 <= transferNo <= originally requested number of transfers
Remarks:
Once a channel has been configured once with ECPY_configure(), ECPY_configure32() can be used to update any of the 32-bit parameter fields, for example, the source address of the data to be transferred.
Both an inlined version and a non-inlined version of this function are supported. To use the inlined version, add the line #define ECPY_CONFIGURE32_INLINE or #define ECPY_INLINE_ALL to the source file where this function is used. The #define must go above the line, #include <ecpy.h>. By default, this function will not be inlined. Another alternative is to define the macro in the build option of the file or of the project file.
Void ECPY_directConfigure32 ( ECPY_Handle  handle,
ECPY_ParamField32b  fieldId,
unsigned int  value,
short  transferNo 
)

Modify the 32-bit DMA transfer parameter, indicated by the parameter field id, fieldId, of the current channel settings.

Parameters:
[in]handleECPY channel handle.
[in]fieldIdIndicates which of the parameters is to be modified.
[in]valueNew value of the parameter to be modified.
[in]transferNoIndicates which transfer the parameters correspond to (same value that would be passed to ECPY_configure()).
Precondition:
handle must be a valid channel handle.
Algorithm instance must be in "active" state using IALG interface.
Channel must be in 'active' state.
ECPY_directConfigure() must have previously been called at least once since channel activation.
1 <= transferNo <= originally requested number of transfers
Remarks:
Once a channel has been configured once with ECPY_directConfigure(), the ECPY_directConfigure32() functino can be called to update any of the 32-bit parameter fields, for example, the source address of the data to be transferred.
Both an inlined version and a non-inlined version of this function are supported. To use the inlined version, add the line #define ECPY_CONFIGURE32_INLINE or #define ECPY_INLINE_ALL to the source file where this function is used. The #define must go above the line, #include <ecpy.h>. By default, this function will not be inlined. Another alternative is to define the macro in the build option of the file or of the project file.
Void ECPY_setFinal ( ECPY_Handle  handle,
short  transferNo 
)

Indicate that a given transfer will be the last in a sequence of linked transfers.

This API can be used to dynamically change the number of transfers in a linked transfers.

Parameters:
[in]handleECPY channel handle.
[in]transferNoIndicates the transfer number that will be the last one of the set of linked transfers.
Precondition:
Valid channel handle.
Channel must be in 'active' state.
1 <= transferNo <= originally requested number of transfers
ECPY_cnfigure() must have previously been called at least once since channel activation.
Remarks:
This API can be used if a channel was created to transfer 'numTransfers' linked transfers, but at some point, it will be used to transfer a different number of transfers.
Void ECPY_directSetFinal ( ECPY_Handle  handle,
short  transferNo 
)

Indicate that a given transfer will be the last in a sequence of linked transfers.

This API can be used to dynamically change the number of transfers in a linked transfers.

Parameters:
[in]handleECPY channel handle.
[in]transferNoIndicates the transfer number that will be the last one of the set of linked transfers.
Precondition:
Valid channel handle.
Channel must be in 'active' state.
1 <= transferNo <= originally requested number of transfers
ECPY_directConfigure() must have previously been called at least once since channel activation.
Remarks:
This API can be used if a channel was created to transfer 'numTransfers' linked transfers, but at some point, it will be used to transfer a different number of transfers.
Void ECPY_setDestinationMemoryMode ( ECPY_Handle  handle,
short  mode 
)

Indicate the memory space that DMA transfers submitted to the channel associated with the handle will modify. This information can be used for channel to TC Queue mapping for avoiding known Silicon GEM lockup issues or for performance improvements.

Parameters:
[in]handleECPY channel handle.
[in]modeDMA destination description of type IRES_EDMA3CHAN_DmaDestType.
Void ECPY_start ( ECPY_Handle  handle )

Submit a single or linked transfer using the most recently configured transfer parameter settings.

Parameters:
[in]handleECPY channel handle.
Precondition:
Valid channel handle.
Channel must be in 'active' state.
Channel must be in 'configured' state.
ECPY_configure() must be called at least once for each transfer that will be started.
Remarks:
Most recent ECPY_configure(), ECPY_configure16 and ECPY_configure32 settings will be in effect for each transfer.
Precondition:
When the number of transfers assigned to the channel are > 1, this function will submit a set of linked EDMA transfers, ordered by the transferNo's of the channel. The final transfer of the linked set will be the transfer indicated by the most recent ECPY_setFinal() call. If no ECPY_setFinal has been previously called, then all transfers assigned to the channel will be linked together.
Postcondition:
handle->transferPending = TRUE
Void ECPY_directStartEdma ( ECPY_Handle  handle )

Submit a single or linked transfer using the most recently 'direct' configured transfer parameter settings.

Parameters:
[in]handleECPY channel handle.
Precondition:
Valid channel handle.
Channel must be in 'active' state.
Channel must be in 'direct configured' state.
ECPY_directConfigure() must be called at least once for each transfer that will be started.
1st Transfer of the channel must always be re-configured via direct configure APIs following a (linked) ECPY_directStartEdma i.e. when the number of the most recent start > 1) or when the 1st transfer of the previous start was a 3D transfer (numFrames > 1).
Remarks:
Most recent ECPY_directConfigure(), ECPY_directConfigure16 and ECPY_directConfigure32 settings will always be in effect for each transfer w/transferNo > 1. Transfer settings of transferNo=1 will be only preserved if the most recent ECPY_directStartEdma resulted in a single (non-linked) transfer with numFrames == 1.
Precondition:
When the number of transfers assigned to the channel are > 1, this function will submit a set of linked EDMA transfers, ordered by the transferNo's of the channel. The final transfer of the linked set will be the transfer indicated by the most recent ECPY_directSetFinal() call. If no ECPY_setFinal has been previously called, then all transfers assigned to the channel will be linked together.
Void ECPY_directStartQdma ( ECPY_Handle  handle )

ECPY_directStartQdma has not been implemented.

Void ECPY_wait ( ECPY_Handle  handle )

Wait for all data transfers on a logical channel to complete.

Parameters:
[in]handleECPY channel handle.
Precondition:
Valid channel handle
Channel must be in 'active' state.
ECPY_wait can be called back to back or without having submitted transfers to the channel. For the case there is no pending transfer on the channel it will return immediately.
Postcondition:
ECPY_wait will reset channel handle's transferPending flag to 0
Remarks:
This function will not return until all the previously submitted EDMA transfers on the channel have completed.
Both an inlined version and a non-inlined version of this function are supported. To use the inlined version, add the line #define ECPY_WAIT_INLINE or #define ECPY_INLINE_ALL to the source file where this function is used. The #define must go above the line, #include <ecpy.h>. By default, this function will not be inlined. Another alternative is to define the macro in the build option of the file or of the project file.
Void ECPY_directWait ( ECPY_Handle  handle )

Wait for all EDMA data transfers submitted to the logical channel via ECPY_directStartEdma to complete.

Parameters:
[in]handleECPY channel handle.
Precondition:
Valid channel handle
Channel must be in 'active' state.
ECPY_directWait requires that a transfer has been submitted to the channel using ECPY_directStartEdma. Otherwise it will block indefinitely.
ECPY_directWait can not be called back to back or without having started EDMA transfers on the channel.
Remarks:
ECPY_directWait will not maintain channel handle's transferPending state.
This function will not return until all the data transfers on the given channel have completed.
Both an inlined version and a non-inlined version of this function are supported. To use the inlined version, add the line #define ECPY_DIRECTWAIT_INLINE or #define ECPY_INLINE_ALL to the source file where this function is used. The #define must go above the line, #include <ecpy.h>. By default, this function will not be inlined. Another alternative is to define the macro in the build option of the file or of the project file.
Void ECPY_activate ( ECPY_Handle  handle )

Activate the given channel.

Parameters:
[in]handleECPY channel handle.
Precondition:
handle must be a valid channel handle.
Algorithm instance must be in "active" state using IALG interface.
handle must be a valid handle obtained by ECPY_createHandle.
Postcondition:
Channel is in 'active' state, any ECPY APIs can be called using this handle.
ECPY_Handle ECPY_createHandle ( IRES_EDMA3CHAN2_Handle  handle,
IALG_Handle  alg 
)

Create an ECPY Handle using the supplied IRES_EDMA3CHAN handle.

Parameters:
[in]handleIRES_EDMA3CHAN channel handle.
[in]algIALG handle.
Precondition:
handle must be a valid handle.
Postcondition:
Early Completion Mode is enabled for all Intermediate Transfers. Early Completion Transfer completion mode can be disabled if needed via the ECPY_setEarlyCompletionMode() API.
Void ECPY_deleteHandle ( ECPY_Handle  handle )

Delete ECPY_Handle.

Parameters:
[in]handleECPY channel handle.
Precondition:
handle must be a valid handle obtained by ECPY_createHandle.
Void ECPY_deactivate ( ECPY_Handle  handle )

Deactivates the given channel.

Parameters:
[in]handleECPY channel handle.
Precondition:
handle must be a valid channel handle.
Channel must be in 'active' state.
Algorithm instance must be in 'active' state using IALG interface
Postcondition:
Channel is in 'deactivated' state.
Void ECPY_setEarlyCompletionMode ( ECPY_Handle  handle,
short  enabled 
)

Setting the TCCMODE (Early or Normal) affects only the 'intermediate transfers' of the linked transfers submitted using this channel. All subsequent direct and non-direct ECPY_configure* calls using this ecpyHandle will program the OPT's TCCMODE to select Early or Normal completion mode based on the 'enabled' argument.

Selecting the Early Completion mode may lead to performance improvements by increasing the EDMA throughput of linked transfers by submitting each transfer request from the EDMA Channel Controller to the Transfer Controller without waiting for the completion of the previous transfer from the Transfer Controller.

Parameters:
[in]handleECPY channel handle.
[in]enabled1/TRUE to set TCCMODE to 1 (Early Completion) 0/FALSE to set TCCMODE to 1 (Normal Completion)
Postcondition:
Channel Intermediate Transfer Completion Mode is set according to the 'enabled' parameter. The selected mode applies to all subsequent configure operations of the intermediate transfers.
Void ECPY_init ( Void   )

Initialize the ECPY module. Called by framework.

Void ECPY_exit ( Void   )

Finalization of the ECPY module.


Define Documentation

#define ti_sdo_fc_ires_NOPROTOCOLREV
#define ECPY_GTNAME   "ti.sdo.fc.ecpy"
#define ECPY_MODNAME   "ti.sdo.fc.ecpy"

Name to pass to Diags_setMask() to enable logging for ECPY functions. For example, Diags_setMask(ECPY_MODNAME"+EX1234567"); turns on all Log statements in this module. Diags_setMask() must be called after initialization to take effect.


Typedef Documentation

ECPY 16-bit param field structure. These values are passed to ECPY_configure16() to indicate the field of the ECPY_Params structure to be changed.

ECPY 32-bit param field structure. These values are passed to ECPY_configure32() to indicate the field of the ECPY_Params structure to be changed.

ECPY DMA Transfer Types:

Note that all transfers can be specified using the ECPY_2D2D transfer type, and providing element and frame indices for both source and destination. However, the other transfer types are provided to simplify configuration when applicable. For example, when using the ECPY_1D2D transfer type, you do not need to set the source element and frame indices in the ECPY_Params structure.

typedef struct ECPY_Obj* ECPY_Handle

Handle to "logical" ECPY Channel.

typedef struct ECPY_Params ECPY_Params

DMA transfer specific parameters. Defines the configuration of a logical channel.

typedef Bool( ECPY_PersistentAllocFxn)(IALG_MemRec *memTab, Int numRecs)

Memory allocation function signature for module configuration.

typedef Void( ECPY_PersistentFreeFxn)(IALG_MemRec *memTab, Int numRecs)

Memory deallocation function signature for module configuration.

typedef Bool( ECPY_ScratchAllocFxn)(IALG_Handle alg, Int scratchId, IALG_MemRec *memTab, Int numRecs)

Scratch Memory allocation function for all shared scratch ECPY handle state.

typedef Void( ECPY_ScratchFreeFxn)(Int mutexId, Void *addr, UInt size)

Scratch Memory free function for all scratch allocated memory in ECPY Handle.

typedef Int( ECPY_getScratchIdFxn)(IALG_Handle alg)

Function, when supplied, returns the scratchId associated with the algorithm instance whose handle is passed.

The module configuration structure for ECPY. It is set at design time by the system integrator to register customize memory allocation/free implementations.

Remarks:
Typically, system integrators configure these settings using XDC config scripts. System integrators that use that method of configuration can ignore this structure definition. It's auto-generated during the config step by the XDC Tools.

Enumeration Type Documentation

ECPY 16-bit param field structure. These values are passed to ECPY_configure16() to indicate the field of the ECPY_Params structure to be changed.

Enumerator:
ECPY_PARAMFIELD_ELEMENTSIZE 
ECPY_PARAMFIELD_NUMELEMENTS 
ECPY_PARAMFIELD_ELEMENTINDEX_SRC 
ECPY_PARAMFIELD_ELEMENTINDEX_DST 
ECPY_PARAMFIELD_FRAMEINDEX_SRC 
ECPY_PARAMFIELD_FRAMEINDEX_DST 
ECPY_PARAMFIELD_NUMFRAMES 

ECPY 32-bit param field structure. These values are passed to ECPY_configure32() to indicate the field of the ECPY_Params structure to be changed.

Enumerator:
ECPY_PARAMFIELD_SRCADDR 
ECPY_PARAMFIELD_DSTADDR 
ECPY_PARAMFIELD_ELEMENTINDEXES 
ECPY_PARAMFIELD_FRAMEINDEXES 

ECPY DMA Transfer Types:

Note that all transfers can be specified using the ECPY_2D2D transfer type, and providing element and frame indices for both source and destination. However, the other transfer types are provided to simplify configuration when applicable. For example, when using the ECPY_1D2D transfer type, you do not need to set the source element and frame indices in the ECPY_Params structure.

Enumerator:
ECPY_1D1D 

Only one element is copied from source to destination. The size of the element is specified in the elementSize field of ECPY_Params

ECPY_1D2D 

After each element is copied to destination, the source and destination of the next element to copy is updated as follows:

  • src = src + element size
  • dst = dst + destination element index

After an entire frame is copied (the frame size specified by the numElements field of ECPY_Params), the source and destination of the next frame to copy are given by:

  • src = src + element size
  • dst = start of frame + destination frame index
ECPY_2D1D 

This is similar to ECPY_1D2D, except that source and destination are updated after an element is copied, as follows:

  • src = src + source element index
  • dst = dst + element size

After an entire frame is copied by:

  • src = start of frame + source frame index
  • dst = dst + element size
ECPY_2D2D 

This transfer type combines ECPY_1D2D and ECPY_2D1D, so that source and destination are updated after an element is copied by:

  • src = src + source element index
  • dst = dst + destination element index

After a frame is copied by:

  • src = start of frame + source frame index
  • dst = start of frame + destination frame index

Variable Documentation

Initialization parameters for the ECPY module.

 All Data Structures Files Functions Variables Typedefs Enumerations Enumerator Defines

Copyright 2012, Texas Instruments Incorporated