em_dma.h

Go to the documentation of this file.

/***************************************************************************/
#ifndef EM_DMA_H
#define EM_DMA_H

#include "em_device.h"
#if defined( DMA_PRESENT )

#include <stdio.h>
#include <stdbool.h>

#ifdef __cplusplus
extern "C" {
#endif

/***************************************************************************/
/***************************************************************************/
/*******************************************************************************
 ********************************   ENUMS   ************************************
 ******************************************************************************/

typedef enum
{
  dmaDataInc1    = _DMA_CTRL_SRC_INC_BYTE,     
  dmaDataInc2    = _DMA_CTRL_SRC_INC_HALFWORD, 
  dmaDataInc4    = _DMA_CTRL_SRC_INC_WORD,     
  dmaDataIncNone = _DMA_CTRL_SRC_INC_NONE      
} DMA_DataInc_TypeDef;


typedef enum
{
  dmaDataSize1 = _DMA_CTRL_SRC_SIZE_BYTE,     
  dmaDataSize2 = _DMA_CTRL_SRC_SIZE_HALFWORD, 
  dmaDataSize4 = _DMA_CTRL_SRC_SIZE_WORD      
} DMA_DataSize_TypeDef;


typedef enum
{
  dmaCycleCtrlBasic            = _DMA_CTRL_CYCLE_CTRL_BASIC,
  dmaCycleCtrlAuto             = _DMA_CTRL_CYCLE_CTRL_AUTO,
  dmaCycleCtrlPingPong         = _DMA_CTRL_CYCLE_CTRL_PINGPONG,
  dmaCycleCtrlMemScatterGather = _DMA_CTRL_CYCLE_CTRL_MEM_SCATTER_GATHER,
  dmaCycleCtrlPerScatterGather = _DMA_CTRL_CYCLE_CTRL_PER_SCATTER_GATHER
} DMA_CycleCtrl_TypeDef;


typedef enum
{
  dmaArbitrate1    = _DMA_CTRL_R_POWER_1,    
  dmaArbitrate2    = _DMA_CTRL_R_POWER_2,    
  dmaArbitrate4    = _DMA_CTRL_R_POWER_4,    
  dmaArbitrate8    = _DMA_CTRL_R_POWER_8,    
  dmaArbitrate16   = _DMA_CTRL_R_POWER_16,   
  dmaArbitrate32   = _DMA_CTRL_R_POWER_32,   
  dmaArbitrate64   = _DMA_CTRL_R_POWER_64,   
  dmaArbitrate128  = _DMA_CTRL_R_POWER_128,  
  dmaArbitrate256  = _DMA_CTRL_R_POWER_256,  
  dmaArbitrate512  = _DMA_CTRL_R_POWER_512,  
  dmaArbitrate1024 = _DMA_CTRL_R_POWER_1024  
} DMA_ArbiterConfig_TypeDef;


/*******************************************************************************
 *******************************   STRUCTS   ***********************************
 ******************************************************************************/

typedef void (*DMA_FuncPtr_TypeDef)(unsigned int channel, bool primary, void *user);


typedef struct
{
  DMA_FuncPtr_TypeDef cbFunc;

  void                *userPtr;

  uint8_t             primary;
} DMA_CB_TypeDef;


typedef struct
{
  bool     highPri;

  bool     enableInt;

  uint32_t select;

  DMA_CB_TypeDef *cb;
} DMA_CfgChannel_TypeDef;


typedef struct
{
  DMA_DataInc_TypeDef       dstInc;

  DMA_DataInc_TypeDef       srcInc;

  DMA_DataSize_TypeDef      size;

  DMA_ArbiterConfig_TypeDef arbRate;

  uint8_t hprot;
} DMA_CfgDescr_TypeDef;


#if defined( _DMA_LOOP0_MASK ) && defined( _DMA_LOOP1_MASK )

typedef struct
{
  bool      enable;
  uint16_t  nMinus1;
} DMA_CfgLoop_TypeDef;
#endif


#if defined( _DMA_RECT0_MASK )

typedef struct
{
  uint16_t dstStride;
  uint16_t srcStride;
  uint16_t height;
} DMA_CfgRect_TypeDef;
#endif


typedef struct
{
  void                      *src;

  void                      *dst;

  DMA_DataInc_TypeDef       dstInc;

  DMA_DataInc_TypeDef       srcInc;

  DMA_DataSize_TypeDef      size;

  DMA_ArbiterConfig_TypeDef arbRate;

  uint16_t                  nMinus1;

  uint8_t hprot;

  bool    peripheral;
} DMA_CfgDescrSGAlt_TypeDef;


typedef struct
{
  uint8_t hprot;

  DMA_DESCRIPTOR_TypeDef *controlBlock;
} DMA_Init_TypeDef;


/*******************************************************************************
 *****************************   PROTOTYPES   **********************************
 ******************************************************************************/

void DMA_ActivateAuto(unsigned int channel,
                      bool primary,
                      void *dst,
                      const void *src,
                      unsigned int nMinus1);
void DMA_ActivateBasic(unsigned int channel,
                       bool primary,
                       bool useBurst,
                       void *dst,
                       const void *src,
                       unsigned int nMinus1);
void DMA_ActivatePingPong(unsigned int channel,
                          bool useBurst,
                          void *primDst,
                          const void *primSrc,
                          unsigned int primNMinus1,
                          void *altDst,
                          const void *altSrc,
                          unsigned int altNMinus1);
void DMA_ActivateScatterGather(unsigned int channel,
                               bool useBurst,
                               DMA_DESCRIPTOR_TypeDef *altDescr,
                               unsigned int count);
void DMA_CfgChannel(unsigned int channel, DMA_CfgChannel_TypeDef *cfg);
void DMA_CfgDescr(unsigned int channel,
                  bool primary,
                  DMA_CfgDescr_TypeDef *cfg);
#if defined( _DMA_LOOP0_MASK ) && defined( _DMA_LOOP1_MASK )
void DMA_CfgLoop(unsigned int channel, DMA_CfgLoop_TypeDef *cfg);
#endif

#if defined( _DMA_RECT0_MASK )
void DMA_CfgRect(unsigned int channel, DMA_CfgRect_TypeDef *cfg);
#endif

#if defined( _DMA_LOOP0_MASK ) && defined( _DMA_LOOP1_MASK )
/***************************************************************************/
__STATIC_INLINE void DMA_ResetLoop(unsigned int channel)
{
  /* Clean loop copy operation */
  switch(channel)
  {
    case 0:
      DMA->LOOP0 = _DMA_LOOP0_RESETVALUE;
      break;
    case 1:
      DMA->LOOP1 = _DMA_LOOP1_RESETVALUE;
      break;
    default:
      break;
  }
}
#endif


#if defined( _DMA_RECT0_MASK )
/***************************************************************************/
__STATIC_INLINE void DMA_ResetRect(unsigned int channel)
{
  (void) channel;

  /* Clear rect copy operation */
  DMA->RECT0 = _DMA_RECT0_RESETVALUE;
}
#endif
void DMA_CfgDescrScatterGather(DMA_DESCRIPTOR_TypeDef *descr,
                               unsigned int indx,
                               DMA_CfgDescrSGAlt_TypeDef *cfg);
void DMA_ChannelEnable(unsigned int channel, bool enable);
bool DMA_ChannelEnabled(unsigned int channel);
void DMA_ChannelRequestEnable(unsigned int channel, bool enable);
void DMA_Init(DMA_Init_TypeDef *init);
void DMA_IRQHandler(void);
void DMA_RefreshPingPong(unsigned int channel,
                         bool primary,
                         bool useBurst,
                         void *dst,
                         const void *src,
                         unsigned int nMinus1,
                         bool last);
void DMA_Reset(void);

/***************************************************************************/
__STATIC_INLINE void DMA_IntClear(uint32_t flags)
{
  DMA->IFC = flags;
}


/***************************************************************************/
__STATIC_INLINE void DMA_IntDisable(uint32_t flags)
{
  DMA->IEN &= ~flags;
}


/***************************************************************************/
__STATIC_INLINE void DMA_IntEnable(uint32_t flags)
{
  DMA->IEN |= flags;
}


/***************************************************************************/
__STATIC_INLINE uint32_t DMA_IntGet(void)
{
  return DMA->IF;
}


/***************************************************************************/
__STATIC_INLINE uint32_t DMA_IntGetEnabled(void)
{
  uint32_t ien;

  ien = DMA->IEN;
  return DMA->IF & ien;
}


/***************************************************************************/
__STATIC_INLINE void DMA_IntSet(uint32_t flags)
{
  DMA->IFS = flags;
}

#ifdef __cplusplus
}
#endif

#endif /* defined( DMA_PRESENT ) */
#endif /* EM_DMA_H */