csl_edmahal.h

Ti 6416 环境下UART模块的操作范例

  #define _EDMA_ECR_EC_MASK          0x0000FFFFu
  #define _EDMA_ECR_EC_SHIFT         0x00000000u
  #define  EDMA_ECR_EC_DEFAULT       0x00000000u
  #define  EDMA_ECR_EC_OF(x)         _VALUEOF(x)
#endif

  #define  EDMA_EPR_OF(x)            _VALUEOF(x)

  #define EDMA_ECR_DEFAULT (Uint32)(\
     _PER_FDEFAULT(EDMA,ECR,EC)\
  )

  #define EDMA_ECR_RMK(ec) (Uint32)(\
     _PER_FMK(EDMA,ECR,EC,ec)\
  )

  #define _EDMA_ECR_FGET(FIELD)\
    _PER_FGET(_EDMA_ECR_ADDR,EDMA,ECR,##FIELD)

  #define _EDMA_ECR_FSET(FIELD,field)\
    _PER_FSET(_EDMA_ECR_ADDR,EDMA,ECR,##FIELD,field)

  #define _EDMA_ECR_FSETS(FIELD,SYM)\
    _PER_FSETS(_EDMA_ECR_ADDR,EDMA,ECR,##FIELD,##SYM)


/******************************************************************************\
* _____________________
* |                   |
* |  E C R L          |
* |___________________|
*
* ECRL - event clear register, low half (1)
*
* (1) - C64x devices only
*
* FIELDS (msb -> lsb)
* (rw) EC
*
\******************************************************************************/
#if (C64_SUPPORT)
  #define _EDMA_ECRL_ADDR             0x01A0FFF8u

  #define  EDMA_ECRL                  EDMA_REG(ECRL)

  #define _EDMA_ECRL_EC_MASK          0xFFFFFFFFu
  #define _EDMA_ECRL_EC_SHIFT         0x00000000u
  #define  EDMA_ECRL_EC_DEFAULT       0x00000000u
  #define  EDMA_ECRL_EC_OF(x)         _VALUEOF(x)

  #define  EDMA_EER_OF(x)            _VALUEOF(x)

  #define EDMA_ECRL_DEFAULT (Uint32)(\
     _PER_FDEFAULT(EDMA,ECRL,EC)\
  )

  #define EDMA_ECRL_RMK(ec) (Uint32)(\
     _PER_FMK(EDMA,ECRL,EC,ec)\
  )

  #define _EDMA_ECRL_FGET(FIELD)\
    _PER_FGET(_EDMA_ECRL_ADDR,EDMA,ECRL,##FIELD)

  #define _EDMA_ECRL_FSET(FIELD,field)\
    _PER_FSET(_EDMA_ECRL_ADDR,EDMA,ECRL,##FIELD,field)

  #define _EDMA_ECRL_FSETS(FIELD,SYM)\
    _PER_FSETS(_EDMA_ECRL_ADDR,EDMA,ECRL,##FIELD,##SYM)
#endif


/******************************************************************************\
* _____________________
* |                   |
* |  E C R H          |
* |___________________|
*
* ECRH - event clear register, high half (1)
*
* (1) - C64x devices only
*
* FIELDS (msb -> lsb)
* (rw) EC
*
\******************************************************************************/
#if (C64_SUPPORT)
  #define _EDMA_ECRH_ADDR             0x01A0FFB8u

  #define  EDMA_ECRH                  EDMA_REG(ECRH)

  #define _EDMA_ECRH_EC_MASK          0xFFFFFFFFu
  #define _EDMA_ECRH_EC_SHIFT         0x00000000u
  #define  EDMA_ECRH_EC_DEFAULT       0x00000000u
  #define  EDMA_ECRH_EC_OF(x)         _VALUEOF(x)

  #define  EDMA_EER_OF(x)            _VALUEOF(x)

  #define EDMA_ECRH_DEFAULT (Uint32)(\
     _PER_FDEFAULT(EDMA,ECRH,EC)\
  )

  #define EDMA_ECRH_RMK(ec) (Uint32)(\
     _PER_FMK(EDMA,ECRH,EC,ec)\
  )

  #define _EDMA_ECRH_FGET(FIELD)\
    _PER_FGET(_EDMA_ECRH_ADDR,EDMA,ECRH,##FIELD)

  #define _EDMA_ECRH_FSET(FIELD,field)\
    _PER_FSET(_EDMA_ECRH_ADDR,EDMA,ECRH,##FIELD,field)

  #define _EDMA_ECRH_FSETS(FIELD,SYM)\
    _PER_FSETS(_EDMA_ECRH_ADDR,EDMA,ECRH,##FIELD,##SYM)
#endif


/******************************************************************************\
* _____________________
* |                   |
* |  E S R            |
* |___________________|
*
* ESR - event set register
*
* FIELDS (msb -> lsb)
* (rw) ES
*
\******************************************************************************/
  #define _EDMA_ESR_ADDR             0x01A0FFFCu

  #define  EDMA_ESR                  EDMA_REG(ESR)

#if (C64_SUPPORT)
  #define _EDMA_ESR_ES_MASK          0xFFFFFFFFu
  #define _EDMA_ESR_ES_SHIFT         0x00000000u
  #define  EDMA_ESR_ES_DEFAULT       0x00000000u
  #define  EDMA_ESR_ES_OF(x)         _VALUEOF(x)
#else
  #define _EDMA_ESR_ES_MASK          0x0000FFFFu
  #define _EDMA_ESR_ES_SHIFT         0x00000000u
  #define  EDMA_ESR_ES_DEFAULT       0x00000000u
  #define  EDMA_ESR_ES_OF(x)         _VALUEOF(x)
#endif

  #define  EDMA_ESR_OF(x)            _VALUEOF(x)

  #define EDMA_ESR_DEFAULT (Uint32)(\
     _PER_FDEFAULT(EDMA,ESR,ES)\
  )

  #define EDMA_ESR_RMK(es) (Uint32)(\
     _PER_FMK(EDMA,ESR,ES,es)\
  )

  #define _EDMA_ESR_FGET(FIELD)\
    _PER_FGET(_EDMA_ESR_ADDR,EDMA,ESR,##FIELD)

  #define _EDMA_ESR_FSET(FIELD,field)\
    _PER_FSET(_EDMA_ESR_ADDR,EDMA,ESR,##FIELD,field)

  #define _EDMA_ESR_FSETS(FIELD,SYM)\
    _PER_FSETS(_EDMA_ESR_ADDR,EDMA,ESR,##FIELD,##SYM)


/******************************************************************************\
* _____________________
* |                   |
* |  E S R L          |
* |___________________|
*
* ESRL - event set register, low half (1)
*
* (1) - C64x devices only
*
* FIELDS (msb -> lsb)
* (rw) ES
*
\******************************************************************************/
#if (C64_SUPPORT)
  #define _EDMA_ESRL_ADDR             0x01A0FFFCu

  #define  EDMA_ESRL                  EDMA_REG(ESRL)

  #define _EDMA_ESRL_ES_MASK          0xFFFFFFFFu
  #define _EDMA_ESRL_ES_SHIFT         0x00000000u
  #define  EDMA_ESRL_ES_DEFAULT       0x00000000u
  #define  EDMA_ESRL_ES_OF(x)         _VALUEOF(x)

  #define  EDMA_ESRL_OF(x)            _VALUEOF(x)

  #define EDMA_ESRL_DEFAULT (Uint32)(\
     _PER_FDEFAULT(EDMA,ESRL,ES)\
  )

  #define EDMA_ESRL_RMK(es) (Uint32)(\
     _PER_FMK(EDMA,ESRL,ES,es)\
  )

  #define _EDMA_ESRL_FGET(FIELD)\
    _PER_FGET(_EDMA_ESRL_ADDR,EDMA,ESRL,##FIELD)

  #define _EDMA_ESRL_FSET(FIELD,field)\
    _PER_FSET(_EDMA_ESRL_ADDR,EDMA,ESRL,##FIELD,field)

  #define _EDMA_ESRL_FSETS(FIELD,SYM)\
    _PER_FSETS(_EDMA_ESRL_ADDR,EDMA,ESRL,##FIELD,##SYM)
#endif


/******************************************************************************\
* _____________________
* |                   |
* |  E S R H          |
* |___________________|
*
* ESRH - event set register, high half (1)
*
* (1) - C64x devices only
*
* FIELDS (msb -> lsb)
* (rw) ES
*
\******************************************************************************/
#if (C64_SUPPORT)
  #define _EDMA_ESRH_ADDR             0x01A0FFBCu

  #define  EDMA_ESRH                  EDMA_REG(ESRH)

  #define _EDMA_ESRH_ES_MASK          0xFFFFFFFFu
  #define _EDMA_ESRH_ES_SHIFT         0x00000000u
  #define  EDMA_ESRH_ES_DEFAULT       0x00000000u
  #define  EDMA_ESRH_ES_OF(x)         _VALUEOF(x)

  #define  EDMA_ESRH_OF(x)            _VALUEOF(x)

  #define EDMA_ESRH_DEFAULT (Uint32)(\
     _PER_FDEFAULT(EDMA,ESRH,ES)\
  )

  #define EDMA_ESRH_RMK(es) (Uint32)(\
     _PER_FMK(EDMA,ESRH,ES,es)\
  )

  #define _EDMA_ESRH_FGET(FIELD)\
    _PER_FGET(_EDMA_ESRH_ADDR,EDMA,ESRH,##FIELD)

  #define _EDMA_ESRH_FSET(FIELD,field)\
    _PER_FSET(_EDMA_ESRH_ADDR,EDMA,ESRH,##FIELD,field)

  #define _EDMA_ESRH_FSETS(FIELD,SYM)\
    _PER_FSETS(_EDMA_ESRH_ADDR,EDMA,ESRH,##FIELD,##SYM)
#endif

/******************************************************************************\
* _____________________
* |                   |
* |  E S E L 0        |
* |___________________|
*
* ESEL0 - event selection register 0
*
* FIELDS (msb -> lsb)
* (rw) EVTSEL3
* (rw) EVTSEL2
* (rw) EVTSEL1
* (rw) EVTSEL0
*
\******************************************************************************/
#if (CHIP_6713 || CHIP_DA610 || CHIP_6711C || CHIP_6712C)
  #define _EDMA_ESEL0_ADDR             0x01A0FF00u

  #define  EDMA_ESEL0                  EDMA_REG(ESEL0)

  #define _EDMA_ESEL0_EVTSEL0_MASK     0x0000003Fu
  #define _EDMA_ESEL0_EVTSEL0_SHIFT    0x00000000u
  #define  EDMA_ESEL0_EVTSEL0_DEFAULT  0x00000000u
  #define  EDMA_ESEL0_EVTSEL0_OF(x)    _VALUEOF(x)

  #define _EDMA_ESEL0_EVTSEL1_MASK     0x00003F00u
  #define _EDMA_ESEL0_EVTSEL1_SHIFT    0x00000008u
  #define  EDMA_ESEL0_EVTSEL1_DEFAULT  0x00000001u
  #define  EDMA_ESEL0_EVTSEL1_OF(x)    _VALUEOF(x)

  #define _EDMA_ESEL0_EVTSEL2_MASK     0x003F0000u
  #define _EDMA_ESEL0_EVTSEL2_SHIFT    0x00000010u
  #define  EDMA_ESEL0_EVTSEL2_DEFAULT  0x00000002u
  #define  EDMA_ESEL0_EVTSEL2_OF(x)    _VALUEOF(x)

  #define _EDMA_ESEL0_EVTSEL3_MASK     0x3F000000u
  #define _EDMA_ESEL0_EVTSEL3_SHIFT    0x00000018u
  #define  EDMA_ESEL0_EVTSEL3_DEFAULT  0x00000003u
  #define  EDMA_ESEL0_EVTSEL3_OF(x)    _VALUEOF(x)

  #define  EDMA_ESEL0_OF(x)            _VALUEOF(x)

  #define EDMA_ESEL0_DEFAULT (Uint32)(\
     _PER_FDEFAULT(EDMA,ESEL0,EVTSEL0)\
    |_PER_FDEFAULT(EDMA,ESEL0,EVTSEL1)\
    |_PER_FDEFAULT(EDMA,ESEL0,EVTSEL2)\
    |_PER_FDEFAULT(EDMA,ESEL0,EVTSEL3)\
  )

  #define EDMA_ESEL0_RMK(evtsel0, evtsel1, evtsel2, evtsel3) (Uint32)(\
     _PER_FMK(EDMA,ESEL0,EVTSEL0,evtsel0)\
    |_PER_FMK(EDMA,ESEL0,EVTSEL1,evtsel1)\
    |_PER_FMK(EDMA,ESEL0,EVTSEL2,evtsel2)\
    |_PER_FMK(EDMA,ESEL0,EVTSEL3,evtsel3)\
  )

  #define _EDMA_ESEL0_FGET(FIELD)\
    _PER_FGET(_EDMA_ESEL0_ADDR,EDMA,ESEL0,##FIELD)

  #define _EDMA_ESEL0_FSET(FIELD,field)\
    _PER_FSET(_EDMA_ESEL0_ADDR,EDMA,ESEL0,##FIELD,field)

  #define _EDMA_ESEL0_FSETS(FIELD,SYM)\
    _PER_FSETS(_EDMA_ESEL0_ADDR,EDMA,ESEL0,##FIELD,##SYM)

#endif

/******************************************************************************\
* _____________________
* |                   |
* |  E S E L 1        |
* |___________________|
*
* ESEL1 - event selection register 1
*
* FIELDS (msb -> lsb)
* (rw) EVTSEL7
* (rw) EVTSEL6
* (rw) EVTSEL5
* (rw) EVTSEL4
*
\******************************************************************************/
#if (CHIP_6713 || CHIP_DA610 || CHIP_6711C || CHIP_6712C)
  #define _EDMA_ESEL1_ADDR             0x01A0FF04u

  #define  EDMA_ESEL1                  EDMA_REG(ESEL1)

  #define _EDMA_ESEL1_EVTSEL4_MASK     0x0000003Fu
  #define _EDMA_ESEL1_EVTSEL4_SHIFT    0x00000000u
  #define  EDMA_ESEL1_EVTSEL4_DEFAULT  0x00000004u
  #define  EDMA_ESEL1_EVTSEL4_OF(x)    _VALUEOF(x)

  #define _EDMA_ESEL1_EVTSEL5_MASK     0x00003F00u
  #define _EDMA_ESEL1_EVTSEL5_SHIFT    0x00000008u
  #define  EDMA_ESEL1_EVTSEL5_DEFAULT  0x00000005u
  #define  EDMA_ESEL1_EVTSEL5_OF(x)    _VALUEOF(x)

  #define _EDMA_ESEL1_EVTSEL6_MASK     0x003F0000u
  #define _EDMA_ESEL1_EVTSEL6_SHIFT    0x00000010u
  #define  EDMA_ESEL1_EVTSEL6_DEFAULT  0x00000006u
  #define  EDMA_ESEL1_EVTSEL6_OF(x)    _VALUEOF(x)

  #define _EDMA_ESEL1_EVTSEL7_MASK     0x3F000000u
  #define _EDMA_ESEL1_EVTSEL7_SHIFT    0x00000018u
  #define  EDMA_ESEL1_EVTSEL7_DEFAULT  0x00000007u
  #define  EDMA_ESEL1_EVTSEL7_OF(x)    _VALUEOF(x)

  #define  EDMA_ESEL1_OF(x)            _VALUEOF(x)

  #define EDMA_ESEL1_DEFAULT (Uint32)(\
     _PER_FDEFAULT(EDMA,ESEL1,EVTSEL4)\
    |_PER_FDEFAULT(EDMA,ESEL1,EVTSEL5)\
    |_PER_FDEFAULT(EDMA,ESEL1,EVTSEL6)\
    |_PER_FDEFAULT(EDMA,ESEL1,EVTSEL7)\
  )

  #define EDMA_ESEL1_RMK(evtsel4, evtsel5, evtsel6, evtsel7) (Uint32)(\
     _PER_FMK(EDMA,ESEL1,EVTSEL4,evtsel4)\
    |_PER_FMK(EDMA,ESEL1,EVTSEL5,evtsel5)\
    |_PER_FMK(EDMA,ESEL1,EVTSEL6,evtsel6)\
    |_PER_FMK(EDMA,ESEL1,EVTSEL7,evtsel7)\
  )

  #define _EDMA_ESEL1_FGET(FIELD)\
    _PER_FGET(_EDMA_ESEL1_ADDR,EDMA,ESEL1,##FIELD)

  #define _EDMA_ESEL1_FSET(FIELD,field)\
    _PER_FSET(_EDMA_ESEL1_ADDR,EDMA,ESEL1,##FIELD,field)

  #define _EDMA_ESEL1_FSETS(FIELD,SYM)\
    _PER_FSETS(_EDMA_ESEL1_ADDR,EDMA,ESEL1,##FIELD,##SYM)

#endif

/******************************************************************************\
* _____________________
* |                   |
* |  E S E L 3        |
* |___________________|
*
* ESEL3 - event selection register 3
*
* FIELDS (msb -> lsb)
* (rw) EVTSEL15
* (rw) EVTSEL14
* (rw) EVTSEL13
* (rw) EVTSEL12
*
\******************************************************************************/
#if (CHIP_6713 || CHIP_DA610 || CHIP_6711C || CHIP_6712C)
  #define _EDMA_ESEL3_ADDR             0x01A0FF0Cu

  #define  EDMA_ESEL3                  EDMA_REG(ESEL3)

  #define _EDMA_ESEL3_EVTSEL12_MASK     0x0000003Fu
  #define _EDMA_ESEL3_EVTSEL12_SHIFT    0x00000000u
  #define  EDMA_ESEL3_EVTSEL12_DEFAULT  0x0000000Cu
  #define  EDMA_ESEL3_EVTSEL12_OF(x)    _VALUEOF(x)

  #define _EDMA_ESEL3_EVTSEL13_MASK     0x00003F00u
  #define _EDMA_ESEL3_EVTSEL13_SHIFT    0x00000008u
  #define  EDMA_ESEL3_EVTSEL13_DEFAULT  0x0000000Du
  #define  EDMA_ESEL3_EVTSEL13_OF(x)    _VALUEOF(x)

  #define _EDMA_ESEL3_EVTSEL14_MASK     0x003F0000u
  #define _EDMA_ESEL3_EVTSEL14_SHIFT    0x00000010u
  #define  EDMA_ESEL3_EVTSEL14_DEFAULT  0x0000000Eu
  #define  EDMA_ESEL3_EVTSEL14_OF(x)    _VALUEOF(x)

  #define _EDMA_ESEL3_EVTSEL15_MASK     0x3F000000u
  #define _EDMA_ESEL3_EVTSEL15_SHIFT    0x00000018u
  #define  EDMA_ESEL3_EVTSEL15_DEFAULT  0x0000000Fu
  #define  EDMA_ESEL3_EVTSEL15_OF(x)    _VALUEOF(x)

  #define  EDMA_ESEL3_OF(x)            _VALUEOF(x)

  #define EDMA_ESEL3_DEFAULT (Uint32)(\
     _PER_FDEFAULT(EDMA,ESEL3,EVTSEL12)\
    |_PER_FDEFAULT(EDMA,ESEL3,EVTSEL13)\
    |_PER_FDEFAULT(EDMA,ESEL3,EVTSEL14)\
    |_PER_FDEFAULT(EDMA,ESEL3,EVTSEL15)\
  )

  #define EDMA_ESEL3_RMK(evtsel12, evtsel13, evtsel14, evtsel15) (Uint32)(\