csl_clkchal_270.h

dm270 source code

* Register Macros for CLKC DIV register :
*                                                                                    
*                                                                                    
*                                                                                    
*---------------------------------------------------------------------------------*/

#define _CLKC_DIV_GET()			_REG_GET(_CLKC_DIV_ADDR)
#define _CLKC_DIV_SET(Val)			_REG_SET(_CLKC_DIV_ADDR, Val)
#define _CLKC_DIV_AOI(AND,OR,INV)		_REG_AOI(_CLKC_DIV_ADDR,AND,OR,INV)
#define _CLKC_DIV_FGET(Field)			_FIELD_GET(_CLKC_DIV_ADDR, _CLKC_DIV_##Field##)
#define _CLKC_DIV_FSET(Field, Val)		_FIELD_SET(_CLKC_DIV_ADDR, _CLKC_DIV_##Field##, Val)
#define _CLKC_DIV_FAOI(Field, AND, OR, INV)	_FIELD_AOI(_CLKC_DIV_ADDR, _CLKC_DIV_##Field##, AND, OR, INV)

#define _CLKC_DIV_CAXDIV_SHIFT		(12)
#define _CLKC_DIV_CAXDIV_MK(n)		(((Uint16)(n) & 0x0003u) << _CLKC_DIV_CAXDIV_SHIFT)
#define _CLKC_DIV_CAXDIV_MASK			(_CLKC_DIV_CAXDIV_MK(0x0003u))
#define _CLKC_DIV_CAXDIV_CLR			(~(_CLKC_DIV_CAXDIV_MASK))

#define _CLKC_DIV_CSDIV_SHIFT		(8)
#define _CLKC_DIV_CSDIV_MK(n)		(((Uint16)(n) & 0x0003u) << _CLKC_DIV_CSDIV_SHIFT)
#define _CLKC_DIV_CSDIV_MASK			(_CLKC_DIV_CSDIV_MK(0x0003u))
#define _CLKC_DIV_CSDIV_CLR			(~(_CLKC_DIV_CSDIV_MASK))

#define _CLKC_DIV_CDDIV_SHIFT		(4)
#define _CLKC_DIV_CDDIV_MK(n)		(((Uint16)(n) & 0x0003u) << _CLKC_DIV_CDDIV_SHIFT)
#define _CLKC_DIV_CDDIV_MASK			(_CLKC_DIV_CDDIV_MK(0x0003u))
#define _CLKC_DIV_CDDIV_CLR			(~(_CLKC_DIV_CDDIV_MASK))

#define _CLKC_DIV_CADIV_SHIFT		(0)
#define _CLKC_DIV_CADIV_MK(n)		((Uint16)(n) & 0x0003u) 
#define _CLKC_DIV_CADIV_MASK			(_CLKC_DIV_CADIV_MK(0x0003u))
#define _CLKC_DIV_CADIV_CLR			(~(_CLKC_DIV_CADIV_MASK))



/*------------------------------------------------------------------------------*
* Register Macros for CLKC BYP register :
*                                                                                    
*                                                                                    
*                                                                                    
*---------------------------------------------------------------------------------*/

#define _CLKC_BYP_GET()			_REG_GET(_CLKC_BYP_ADDR)
#define _CLKC_BYP_SET(Val)			_REG_SET(_CLKC_BYP_ADDR, Val)
#define _CLKC_BYP_AOI(AND,OR,INV)		_REG_AOI(_CLKC_BYP_ADDR,AND,OR,INV)
#define _CLKC_BYP_FGET(Field)			_FIELD_GET(_CLKC_BYP_ADDR, _CLKC_BYP_##Field##)
#define _CLKC_BYP_FSET(Field, Val)		_FIELD_SET(_CLKC_BYP_ADDR, _CLKC_BYP_##Field##, Val)
#define _CLKC_BYP_FAOI(Field, AND, OR, INV)	_FIELD_AOI(_CLKC_BYP_ADDR, _CLKC_BYP_##Field##, AND, OR, INV)

#define _CLKC_BYP_CMB_SHIFT		(12)
#define _CLKC_BYP_CMB_MK(n)		(((Uint16)(n) & 0x0001u) << _CLKC_BYP_CMB_SHIFT)
#define _CLKC_BYP_CMB_MASK			(_CLKC_BYP_CMB_MK(0x0001u))
#define _CLKC_BYP_CMB_CLR			(~(_CLKC_BYP_CMB_MASK))

#define _CLKC_BYP_CSB_SHIFT		(8)
#define _CLKC_BYP_CSB_MK(n)		(((Uint16)(n) & 0x0001u) << _CLKC_BYP_CSB_SHIFT)
#define _CLKC_BYP_CSB_MASK			(_CLKC_BYP_CSB_MK(0x0001u))
#define _CLKC_BYP_CSB_CLR			(~(_CLKC_BYP_CSB_MASK))

#define _CLKC_BYP_CDB_SHIFT		(4)
#define _CLKC_BYP_CDB_MK(n)		(((Uint16)(n) & 0x0001u) << _CLKC_BYP_CDB_SHIFT)
#define _CLKC_BYP_CDB_MASK			(_CLKC_BYP_CDB_MK(0x0001u))
#define _CLKC_BYP_CDB_CLR			(~(_CLKC_BYP_CDB_MASK))

#define _CLKC_BYP_CAB_SHIFT		(0)
#define _CLKC_BYP_CAB_MK(n)		((Uint16)(n) & 0x0001u) 
#define _CLKC_BYP_CAB_MASK			(_CLKC_BYP_CAB_MK(0x0001u))
#define _CLKC_BYP_CAB_CLR			(~(_CLKC_BYP_CAB_MASK))



/*------------------------------------------------------------------------------*
* Register Macros for CLKC MMCCLK register :
*                                                                                    
*                                                                                    
*                                                                                    
*---------------------------------------------------------------------------------*/

#define _CLKC_MMCCLK_GET()			_REG_GET(_CLKC_MMCCLK_ADDR)
#define _CLKC_MMCCLK_SET(Val)			_REG_SET(_CLKC_MMCCLK_ADDR, Val)
#define _CLKC_MMCCLK_AOI(AND,OR,INV)		_REG_AOI(_CLKC_MMCCLK_ADDR,AND,OR,INV)
#define _CLKC_MMCCLK_FGET(Field)			_FIELD_GET(_CLKC_MMCCLK_ADDR, _CLKC_MMCCLK_##Field##)
#define _CLKC_MMCCLK_FSET(Field, Val)		_FIELD_SET(_CLKC_MMCCLK_ADDR, _CLKC_MMCCLK_##Field##, Val)
#define _CLKC_MMCCLK_FAOI(Field, AND, OR, INV)	_FIELD_AOI(_CLKC_MMCCLK_ADDR, _CLKC_MMCCLK_##Field##, AND, OR, INV)

#define _CLKC_MMCCLK_CMDIV_SHIFT		(0)
#define _CLKC_MMCCLK_CMDIV_MK(n)		((Uint16)(n) & 0x00ffu) 
#define _CLKC_MMCCLK_CMDIV_MASK			(_CLKC_MMCCLK_CMDIV_MK(0x00ffu))
#define _CLKC_MMCCLK_CMDIV_CLR			(~(_CLKC_MMCCLK_CMDIV_MASK))



/*------------------------------------------------------------------------------*
* Register Macros for CLKC CTEST register :
*                                                                                    
*                                                                                    
*                                                                                    
*---------------------------------------------------------------------------------*/

#define _CLKC_CTEST_GET()			_REG_GET(_CLKC_CTEST_ADDR)
#define _CLKC_CTEST_SET(Val)			_REG_SET(_CLKC_CTEST_ADDR, Val)
#define _CLKC_CTEST_AOI(AND,OR,INV)		_REG_AOI(_CLKC_CTEST_ADDR,AND,OR,INV)



/*------------------------------------------------------------------------------*
* Register Macros for CLKC MOD0 register :
*                                                                                    
*                                                                                    
*                                                                                    
*---------------------------------------------------------------------------------*/

#define _CLKC_MOD0_GET()			_REG_GET(_CLKC_MOD0_ADDR)
#define _CLKC_MOD0_SET(Val)			_REG_SET(_CLKC_MOD0_ADDR, Val)
#define _CLKC_MOD0_AOI(AND,OR,INV)		_REG_AOI(_CLKC_MOD0_ADDR,AND,OR,INV)
#define _CLKC_MOD0_FGET(Field)			_FIELD_GET(_CLKC_MOD0_ADDR, _CLKC_MOD0_##Field##)
#define _CLKC_MOD0_FSET(Field, Val)		_FIELD_SET(_CLKC_MOD0_ADDR, _CLKC_MOD0_##Field##, Val)
#define _CLKC_MOD0_FAOI(Field, AND, OR, INV)	_FIELD_AOI(_CLKC_MOD0_ADDR, _CLKC_MOD0_##Field##, AND, OR, INV)

#define _CLKC_MOD0_TEST_SHIFT		(15)
#define _CLKC_MOD0_TEST_MK(n)		(((Uint16)(n) & 0x0001u) << _CLKC_MOD0_TEST_SHIFT)
#define _CLKC_MOD0_TEST_MASK			(_CLKC_MOD0_TEST_MK(0x0001u))
#define _CLKC_MOD0_TEST_CLR			(~(_CLKC_MOD0_TEST_MASK))

#define _CLKC_MOD0_CHPIB_SHIFT		(10)
#define _CLKC_MOD0_CHPIB_MK(n)		(((Uint16)(n) & 0x0001u) << _CLKC_MOD0_CHPIB_SHIFT)
#define _CLKC_MOD0_CHPIB_MASK			(_CLKC_MOD0_CHPIB_MK(0x0001u))
#define _CLKC_MOD0_CHPIB_CLR			(~(_CLKC_MOD0_CHPIB_MASK))

#define _CLKC_MOD0_C5409_SHIFT		(9)
#define _CLKC_MOD0_C5409_MK(n)		(((Uint16)(n) & 0x0001u) << _CLKC_MOD0_C5409_SHIFT)
#define _CLKC_MOD0_C5409_MASK			(_CLKC_MOD0_C5409_MK(0x0001u))
#define _CLKC_MOD0_C5409_CLR			(~(_CLKC_MOD0_C5409_MASK))

#define _CLKC_MOD0_CEHIF_SHIFT		(8)
#define _CLKC_MOD0_CEHIF_MK(n)		(((Uint16)(n) & 0x0001u) << _CLKC_MOD0_CEHIF_SHIFT)
#define _CLKC_MOD0_CEHIF_MASK			(_CLKC_MOD0_CEHIF_MK(0x0001u))
#define _CLKC_MOD0_CEHIF_CLR			(~(_CLKC_MOD0_CEHIF_MASK))

#define _CLKC_MOD0_CSDRC_SHIFT		(7)
#define _CLKC_MOD0_CSDRC_MK(n)		(((Uint16)(n) & 0x0001u) << _CLKC_MOD0_CSDRC_SHIFT)
#define _CLKC_MOD0_CSDRC_MASK			(_CLKC_MOD0_CSDRC_MK(0x0001u))
#define _CLKC_MOD0_CSDRC_CLR			(~(_CLKC_MOD0_CSDRC_MASK))

#define _CLKC_MOD0_CEMIF_SHIFT		(6)
#define _CLKC_MOD0_CEMIF_MK(n)		(((Uint16)(n) & 0x0001u) << _CLKC_MOD0_CEMIF_SHIFT)
#define _CLKC_MOD0_CEMIF_MASK			(_CLKC_MOD0_CEMIF_MK(0x0001u))
#define _CLKC_MOD0_CEMIF_CLR			(~(_CLKC_MOD0_CEMIF_MASK))

#define _CLKC_MOD0_CINTC_SHIFT		(5)
#define _CLKC_MOD0_CINTC_MK(n)		(((Uint16)(n) & 0x0001u) << _CLKC_MOD0_CINTC_SHIFT)
#define _CLKC_MOD0_CINTC_MASK			(_CLKC_MOD0_CINTC_MK(0x0001u))
#define _CLKC_MOD0_CINTC_CLR			(~(_CLKC_MOD0_CINTC_MASK))

#define _CLKC_MOD0_CATM_SHIFT		(4)
#define _CLKC_MOD0_CATM_MK(n)		(((Uint16)(n) & 0x0001u) << _CLKC_MOD0_CATM_SHIFT)
#define _CLKC_MOD0_CATM_MASK			(_CLKC_MOD0_CATM_MK(0x0001u))
#define _CLKC_MOD0_CATM_CLR			(~(_CLKC_MOD0_CATM_MASK))

#define _CLKC_MOD0_CADMAC_SHIFT		(3)
#define _CLKC_MOD0_CADMAC_MK(n)		(((Uint16)(n) & 0x0001u) << _CLKC_MOD0_CADMAC_SHIFT)
#define _CLKC_MOD0_CADMAC_MASK			(_CLKC_MOD0_CADMAC_MK(0x0001u))
#define _CLKC_MOD0_CADMAC_CLR			(~(_CLKC_MOD0_CADMAC_MASK))

#define _CLKC_MOD0_CICA_SHIFT		(2)
#define _CLKC_MOD0_CICA_MK(n)		(((Uint16)(n) & 0x0001u) << _CLKC_MOD0_CICA_SHIFT)
#define _CLKC_MOD0_CICA_MASK			(_CLKC_MOD0_CICA_MK(0x0001u))
#define _CLKC_MOD0_CICA_CLR			(~(_CLKC_MOD0_CICA_MASK))

#define _CLKC_MOD0_CBUSC_SHIFT		(1)
#define _CLKC_MOD0_CBUSC_MK(n)		(((Uint16)(n) & 0x0001u) << _CLKC_MOD0_CBUSC_SHIFT)
#define _CLKC_MOD0_CBUSC_MASK			(_CLKC_MOD0_CBUSC_MK(0x0001u))
#define _CLKC_MOD0_CBUSC_CLR			(~(_CLKC_MOD0_CBUSC_MASK))

#define _CLKC_MOD0_CACORE_SHIFT		(0)
#define _CLKC_MOD0_CACORE_MK(n)		((Uint16)(n) & 0x0001u) 
#define _CLKC_MOD0_CACORE_MASK			(_CLKC_MOD0_CACORE_MK(0x0001u))
#define _CLKC_MOD0_CACORE_CLR			(~(_CLKC_MOD0_CACORE_MASK))



/*------------------------------------------------------------------------------*
* Register Macros for CLKC MOD1 register :
*                                                                                    
*                                                                                    
*                                                                                    
*---------------------------------------------------------------------------------*/

#define _CLKC_MOD1_GET()			_REG_GET(_CLKC_MOD1_ADDR)
#define _CLKC_MOD1_SET(Val)			_REG_SET(_CLKC_MOD1_ADDR, Val)
#define _CLKC_MOD1_AOI(AND,OR,INV)		_REG_AOI(_CLKC_MOD1_ADDR,AND,OR,INV)
#define _CLKC_MOD1_FGET(Field)			_FIELD_GET(_CLKC_MOD1_ADDR, _CLKC_MOD1_##Field##)
#define _CLKC_MOD1_FSET(Field, Val)		_FIELD_SET(_CLKC_MOD1_ADDR, _CLKC_MOD1_##Field##, Val)
#define _CLKC_MOD1_FAOI(Field, AND, OR, INV)	_FIELD_AOI(_CLKC_MOD1_ADDR, _CLKC_MOD1_##Field##, AND, OR, INV)

#define _CLKC_MOD1_CIMG_SHIFT		(8)
#define _CLKC_MOD1_CIMG_MK(n)		(((Uint16)(n) & 0x0001u) << _CLKC_MOD1_CIMG_SHIFT)
#define _CLKC_MOD1_CIMG_MASK			(_CLKC_MOD1_CIMG_MK(0x0001u))
#define _CLKC_MOD1_CIMG_CLR			(~(_CLKC_MOD1_CIMG_MASK))

#define _CLKC_MOD1_CIMX_SHIFT		(7)
#define _CLKC_MOD1_CIMX_MK(n)		(((Uint16)(n) & 0x0001u) << _CLKC_MOD1_CIMX_SHIFT)
#define _CLKC_MOD1_CIMX_MASK			(_CLKC_MOD1_CIMX_MK(0x0001u))
#define _CLKC_MOD1_CIMX_CLR			(~(_CLKC_MOD1_CIMX_MASK))

#define _CLKC_MOD1_CVLC_SHIFT		(6)
#define _CLKC_MOD1_CVLC_MK(n)		(((Uint16)(n) & 0x0001u) << _CLKC_MOD1_CVLC_SHIFT)
#define _CLKC_MOD1_CVLC_MASK			(_CLKC_MOD1_CVLC_MK(0x0001u))
#define _CLKC_MOD1_CVLC_CLR			(~(_CLKC_MOD1_CVLC_MASK))

#define _CLKC_MOD1_CDAC_SHIFT		(5)
#define _CLKC_MOD1_CDAC_MK(n)		(((Uint16)(n) & 0x0001u) << _CLKC_MOD1_CDAC_SHIFT)
#define _CLKC_MOD1_CDAC_MASK			(_CLKC_MOD1_CDAC_MK(0x0001u))
#define _CLKC_MOD1_CDAC_CLR			(~(_CLKC_MOD1_CDAC_MASK))

#define _CLKC_MOD1_CVENC_SHIFT		(4)
#define _CLKC_MOD1_CVENC_MK(n)		(((Uint16)(n) & 0x0001u) << _CLKC_MOD1_CVENC_SHIFT)
#define _CLKC_MOD1_CVENC_MASK			(_CLKC_MOD1_CVENC_MK(0x0001u))
#define _CLKC_MOD1_CVENC_CLR			(~(_CLKC_MOD1_CVENC_MASK))

#define _CLKC_MOD1_COSD_SHIFT		(3)
#define _CLKC_MOD1_COSD_MK(n)		(((Uint16)(n) & 0x0001u) << _CLKC_MOD1_COSD_SHIFT)
#define _CLKC_MOD1_COSD_MASK			(_CLKC_MOD1_COSD_MK(0x0001u))
#define _CLKC_MOD1_COSD_CLR			(~(_CLKC_MOD1_COSD_MASK))

#define _CLKC_MOD1_CPRV_SHIFT		(2)
#define _CLKC_MOD1_CPRV_MK(n)		(((Uint16)(n) & 0x0001u) << _CLKC_MOD1_CPRV_SHIFT)
#define _CLKC_MOD1_CPRV_MASK			(_CLKC_MOD1_CPRV_MK(0x0001u))
#define _CLKC_MOD1_CPRV_CLR			(~(_CLKC_MOD1_CPRV_MASK))

#define _CLKC_MOD1_CH3A_SHIFT		(1)
#define _CLKC_MOD1_CH3A_MK(n)		(((Uint16)(n) & 0x0001u) << _CLKC_MOD1_CH3A_SHIFT)
#define _CLKC_MOD1_CH3A_MASK			(_CLKC_MOD1_CH3A_MK(0x0001u))
#define _CLKC_MOD1_CH3A_CLR			(~(_CLKC_MOD1_CH3A_MASK))

#define _CLKC_MOD1_CCCDC_SHIFT		(0)
#define _CLKC_MOD1_CCCDC_MK(n)		((Uint16)(n) & 0x0001u) 
#define _CLKC_MOD1_CCCDC_MASK			(_CLKC_MOD1_CCCDC_MK(0x0001u))
#define _CLKC_MOD1_CCCDC_CLR			(~(_CLKC_MOD1_CCCDC_MASK))



/*------------------------------------------------------------------------------*
* Register Macros for CLKC MOD2 register :
*                                                                                    
*                                                                                    
*                                                                                    
*---------------------------------------------------------------------------------*/

#define _CLKC_MOD2_GET()			_REG_GET(_CLKC_MOD2_ADDR)
#define _CLKC_MOD2_SET(Val)			_REG_SET(_CLKC_MOD2_ADDR, Val)
#define _CLKC_MOD2_AOI(AND,OR,INV)		_REG_AOI(_CLKC_MOD2_ADDR,AND,OR,INV)