csl_clkchal_270.h

dm270 source code

/*   
 *  Copyright 2001 by Texas Instruments Incorporated.
 *  All rights reserved. Property of Texas Instruments Incorporated.
 *  Restricted rights to use, duplicate or disclose this code are
 *  granted through contract.
 */
/******************************************************************************\
*           Copyright (C) 2001 Texas Instruments Incorporated.
*                           All Rights Reserved
*------------------------------------------------------------------------------
* MODULE.NAME... CLKC - HAL configuration module
* FILENAME...... /vobs/DSC_RTOS/arm/project/dm270/include/csl/csl_clkchal_270.h
* PROJECT....... ARM Chip Support Library
* COMPONENT..... HAL
* IMPORTS....... 
*------------------------------------------------------------------------------
* HISTORY:
*   CREATED:       12/06/2001 
*------------------------------------------------------------------------------
* DESCRIPTION:  (CHIP memory mapped register definitions)
*
*
*
\******************************************************************************/



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


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

#define _CLKC_PLLA_GET()			_REG_GET(_CLKC_PLLA_ADDR)
#define _CLKC_PLLA_SET(Val)			_REG_SET(_CLKC_PLLA_ADDR, Val)
#define _CLKC_PLLA_AOI(AND,OR,INV)		_REG_AOI(_CLKC_PLLA_ADDR,AND,OR,INV)
#define _CLKC_PLLA_FGET(Field)			_FIELD_GET(_CLKC_PLLA_ADDR, _CLKC_PLLA_##Field##)
#define _CLKC_PLLA_FSET(Field, Val)		_FIELD_SET(_CLKC_PLLA_ADDR, _CLKC_PLLA_##Field##, Val)
#define _CLKC_PLLA_FAOI(Field, AND, OR, INV)	_FIELD_AOI(_CLKC_PLLA_ADDR, _CLKC_PLLA_##Field##, AND, OR, INV)

#define _CLKC_PLLA_TEST0_SHIFT		(14)
#define _CLKC_PLLA_TEST0_MK(n)		(((Uint16)(n) & 0x0001u) << _CLKC_PLLA_TEST0_SHIFT)
#define _CLKC_PLLA_TEST0_MASK			(_CLKC_PLLA_TEST0_MK(0x0001u))
#define _CLKC_PLLA_TEST0_CLR			(~(_CLKC_PLLA_TEST0_MASK))

#define _CLKC_PLLA_TEST1_SHIFT		(13)
#define _CLKC_PLLA_TEST1_MK(n)		(((Uint16)(n) & 0x0001u) << _CLKC_PLLA_TEST1_SHIFT)
#define _CLKC_PLLA_TEST1_MASK			(_CLKC_PLLA_TEST1_MK(0x0001u))
#define _CLKC_PLLA_TEST1_CLR			(~(_CLKC_PLLA_TEST1_MASK))

#define _CLKC_PLLA_PWRDN_SHIFT		(12)
#define _CLKC_PLLA_PWRDN_MK(n)		(((Uint16)(n) & 0x0001u) << _CLKC_PLLA_PWRDN_SHIFT)
#define _CLKC_PLLA_PWRDN_MASK			(_CLKC_PLLA_PWRDN_MK(0x0001u))
#define _CLKC_PLLA_PWRDN_CLR			(~(_CLKC_PLLA_PWRDN_MASK))

#define _CLKC_PLLA_TEST2_SHIFT		(8)
#define _CLKC_PLLA_TEST2_MK(n)		(((Uint16)(n) & 0x0007u) << _CLKC_PLLA_TEST2_SHIFT)
#define _CLKC_PLLA_TEST2_MASK			(_CLKC_PLLA_TEST2_MK(0x0007u))
#define _CLKC_PLLA_TEST2_CLR			(~(_CLKC_PLLA_TEST2_MASK))

#define _CLKC_PLLA_PMA_SHIFT		(4)
#define _CLKC_PLLA_PMA_MK(n)		(((Uint16)(n) & 0x000fu) << _CLKC_PLLA_PMA_SHIFT)
#define _CLKC_PLLA_PMA_MASK			(_CLKC_PLLA_PMA_MK(0x000fu))
#define _CLKC_PLLA_PMA_CLR			(~(_CLKC_PLLA_PMA_MASK))

#define _CLKC_PLLA_PNA_SHIFT		(0)
#define _CLKC_PLLA_PNA_MK(n)		((Uint16)(n) & 0x0007u) 
#define _CLKC_PLLA_PNA_MASK			(_CLKC_PLLA_PNA_MK(0x0007u))
#define _CLKC_PLLA_PNA_CLR			(~(_CLKC_PLLA_PNA_MASK))



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

#define _CLKC_PLLB_GET()			_REG_GET(_CLKC_PLLB_ADDR)
#define _CLKC_PLLB_SET(Val)			_REG_SET(_CLKC_PLLB_ADDR, Val)
#define _CLKC_PLLB_AOI(AND,OR,INV)		_REG_AOI(_CLKC_PLLB_ADDR,AND,OR,INV)
#define _CLKC_PLLB_FGET(Field)			_FIELD_GET(_CLKC_PLLB_ADDR, _CLKC_PLLB_##Field##)
#define _CLKC_PLLB_FSET(Field, Val)		_FIELD_SET(_CLKC_PLLB_ADDR, _CLKC_PLLB_##Field##, Val)
#define _CLKC_PLLB_FAOI(Field, AND, OR, INV)	_FIELD_AOI(_CLKC_PLLB_ADDR, _CLKC_PLLB_##Field##, AND, OR, INV)

#define _CLKC_PLLB_TEST0_SHIFT		(14)
#define _CLKC_PLLB_TEST0_MK(n)		(((Uint16)(n) & 0x0001u) << _CLKC_PLLB_TEST0_SHIFT)
#define _CLKC_PLLB_TEST0_MASK			(_CLKC_PLLB_TEST0_MK(0x0001u))
#define _CLKC_PLLB_TEST0_CLR			(~(_CLKC_PLLB_TEST0_MASK))

#define _CLKC_PLLB_TEST1_SHIFT		(13)
#define _CLKC_PLLB_TEST1_MK(n)		(((Uint16)(n) & 0x0001u) << _CLKC_PLLB_TEST1_SHIFT)
#define _CLKC_PLLB_TEST1_MASK			(_CLKC_PLLB_TEST1_MK(0x0001u))
#define _CLKC_PLLB_TEST1_CLR			(~(_CLKC_PLLB_TEST1_MASK))

#define _CLKC_PLLB_PWRDN_SHIFT		(12)
#define _CLKC_PLLB_PWRDN_MK(n)		(((Uint16)(n) & 0x0001u) << _CLKC_PLLB_PWRDN_SHIFT)
#define _CLKC_PLLB_PWRDN_MASK			(_CLKC_PLLB_PWRDN_MK(0x0001u))
#define _CLKC_PLLB_PWRDN_CLR			(~(_CLKC_PLLB_PWRDN_MASK))

#define _CLKC_PLLB_TEST2_SHIFT		(8)
#define _CLKC_PLLB_TEST2_MK(n)		(((Uint16)(n) & 0x0007u) << _CLKC_PLLB_TEST2_SHIFT)
#define _CLKC_PLLB_TEST2_MASK			(_CLKC_PLLB_TEST2_MK(0x0007u))
#define _CLKC_PLLB_TEST2_CLR			(~(_CLKC_PLLB_TEST2_MASK))

#define _CLKC_PLLB_PMB_SHIFT		(4)
#define _CLKC_PLLB_PMB_MK(n)		(((Uint16)(n) & 0x000fu) << _CLKC_PLLB_PMB_SHIFT)
#define _CLKC_PLLB_PMB_MASK			(_CLKC_PLLB_PMB_MK(0x000fu))
#define _CLKC_PLLB_PMB_CLR			(~(_CLKC_PLLB_PMB_MASK))

#define _CLKC_PLLB_PNB_SHIFT		(0)
#define _CLKC_PLLB_PNB_MK(n)		((Uint16)(n) & 0x0007u) 
#define _CLKC_PLLB_PNB_MASK			(_CLKC_PLLB_PNB_MK(0x0007u))
#define _CLKC_PLLB_PNB_CLR			(~(_CLKC_PLLB_PNB_MASK))



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

#define _CLKC_CLKC_GET()			_REG_GET(_CLKC_CLKC_ADDR)
#define _CLKC_CLKC_SET(Val)			_REG_SET(_CLKC_CLKC_ADDR, Val)
#define _CLKC_CLKC_AOI(AND,OR,INV)		_REG_AOI(_CLKC_CLKC_ADDR,AND,OR,INV)
#define _CLKC_CLKC_FGET(Field)			_FIELD_GET(_CLKC_CLKC_ADDR, _CLKC_CLKC_##Field##)
#define _CLKC_CLKC_FSET(Field, Val)		_FIELD_SET(_CLKC_CLKC_ADDR, _CLKC_CLKC_##Field##, Val)
#define _CLKC_CLKC_FAOI(Field, AND, OR, INV)	_FIELD_AOI(_CLKC_CLKC_ADDR, _CLKC_CLKC_##Field##, AND, OR, INV)

#define _CLKC_CLKC_CMCIV_SHIFT		(14)
#define _CLKC_CLKC_CMCIV_MK(n)		(((Uint16)(n) & 0x0001u) << _CLKC_CLKC_CMCIV_SHIFT)
#define _CLKC_CLKC_CMCIV_MASK			(_CLKC_CLKC_CMCIV_MK(0x0001u))
#define _CLKC_CLKC_CMCIV_CLR			(~(_CLKC_CLKC_CMCIV_MASK))

#define _CLKC_CLKC_CCDIV_SHIFT		(13)
#define _CLKC_CLKC_CCDIV_MK(n)		(((Uint16)(n) & 0x0001u) << _CLKC_CLKC_CCDIV_SHIFT)
#define _CLKC_CLKC_CCDIV_MASK			(_CLKC_CLKC_CCDIV_MK(0x0001u))
#define _CLKC_CLKC_CCDIV_CLR			(~(_CLKC_CLKC_CCDIV_MASK))

#define _CLKC_CLKC_CENIV_SHIFT		(12)
#define _CLKC_CLKC_CENIV_MK(n)		(((Uint16)(n) & 0x0001u) << _CLKC_CLKC_CENIV_SHIFT)
#define _CLKC_CLKC_CENIV_MASK			(_CLKC_CLKC_CENIV_MK(0x0001u))
#define _CLKC_CLKC_CENIV_CLR			(~(_CLKC_CLKC_CENIV_MASK))

#define _CLKC_CLKC_TEST0_SHIFT		(11)
#define _CLKC_CLKC_TEST0_MK(n)		(((Uint16)(n) & 0x0001u) << _CLKC_CLKC_TEST0_SHIFT)
#define _CLKC_CLKC_TEST0_MASK			(_CLKC_CLKC_TEST0_MK(0x0001u))
#define _CLKC_CLKC_TEST0_CLR			(~(_CLKC_CLKC_TEST0_MASK))

#define _CLKC_CLKC_CUA1S_SHIFT		(10)
#define _CLKC_CLKC_CUA1S_MK(n)		(((Uint16)(n) & 0x0001u) << _CLKC_CLKC_CUA1S_SHIFT)
#define _CLKC_CLKC_CUA1S_MASK			(_CLKC_CLKC_CUA1S_MK(0x0001u))
#define _CLKC_CLKC_CUA1S_CLR			(~(_CLKC_CLKC_CUA1S_MASK))

#define _CLKC_CLKC_CUA0S_SHIFT		(9)
#define _CLKC_CLKC_CUA0S_MK(n)		(((Uint16)(n) & 0x0001u) << _CLKC_CLKC_CUA0S_SHIFT)
#define _CLKC_CLKC_CUA0S_MASK			(_CLKC_CLKC_CUA0S_MK(0x0001u))
#define _CLKC_CLKC_CUA0S_CLR			(~(_CLKC_CLKC_CUA0S_MASK))

#define _CLKC_CLKC_CTM3S_SHIFT		(8)
#define _CLKC_CLKC_CTM3S_MK(n)		(((Uint16)(n) & 0x0001u) << _CLKC_CLKC_CTM3S_SHIFT)
#define _CLKC_CLKC_CTM3S_MASK			(_CLKC_CLKC_CTM3S_MK(0x0001u))
#define _CLKC_CLKC_CTM3S_CLR			(~(_CLKC_CLKC_CTM3S_MASK))

#define _CLKC_CLKC_CTM2S_SHIFT		(7)
#define _CLKC_CLKC_CTM2S_MK(n)		(((Uint16)(n) & 0x0001u) << _CLKC_CLKC_CTM2S_SHIFT)
#define _CLKC_CLKC_CTM2S_MASK			(_CLKC_CLKC_CTM2S_MK(0x0001u))
#define _CLKC_CLKC_CTM2S_CLR			(~(_CLKC_CLKC_CTM2S_MASK))

#define _CLKC_CLKC_CTM1S_SHIFT		(6)
#define _CLKC_CLKC_CTM1S_MK(n)		(((Uint16)(n) & 0x0001u) << _CLKC_CLKC_CTM1S_SHIFT)
#define _CLKC_CLKC_CTM1S_MASK			(_CLKC_CLKC_CTM1S_MK(0x0001u))
#define _CLKC_CLKC_CTM1S_CLR			(~(_CLKC_CLKC_CTM1S_MASK))

#define _CLKC_CLKC_CTM0S_SHIFT		(5)
#define _CLKC_CLKC_CTM0S_MK(n)		(((Uint16)(n) & 0x0001u) << _CLKC_CLKC_CTM0S_SHIFT)
#define _CLKC_CLKC_CTM0S_MASK			(_CLKC_CLKC_CTM0S_MK(0x0001u))
#define _CLKC_CLKC_CTM0S_CLR			(~(_CLKC_CLKC_CTM0S_MASK))

#define _CLKC_CLKC_COSDS_SHIFT		(4)
#define _CLKC_CLKC_COSDS_MK(n)		(((Uint16)(n) & 0x0001u) << _CLKC_CLKC_COSDS_SHIFT)
#define _CLKC_CLKC_COSDS_MASK			(_CLKC_CLKC_COSDS_MK(0x0001u))
#define _CLKC_CLKC_COSDS_CLR			(~(_CLKC_CLKC_COSDS_MASK))

#define _CLKC_CLKC_CCCDS_SHIFT		(3)
#define _CLKC_CLKC_CCCDS_MK(n)		(((Uint16)(n) & 0x0001u) << _CLKC_CLKC_CCCDS_SHIFT)
#define _CLKC_CLKC_CCCDS_MASK			(_CLKC_CLKC_CCCDS_MK(0x0001u))
#define _CLKC_CLKC_CCCDS_CLR			(~(_CLKC_CLKC_CCCDS_MASK))

#define _CLKC_CLKC_CENS1_SHIFT		(2)
#define _CLKC_CLKC_CENS1_MK(n)		(((Uint16)(n) & 0x0001u) << _CLKC_CLKC_CENS1_SHIFT)
#define _CLKC_CLKC_CENS1_MASK			(_CLKC_CLKC_CENS1_MK(0x0001u))
#define _CLKC_CLKC_CENS1_CLR			(~(_CLKC_CLKC_CENS1_MASK))

#define _CLKC_CLKC_CENS0_SHIFT		(1)
#define _CLKC_CLKC_CENS0_MK(n)		(((Uint16)(n) & 0x0001u) << _CLKC_CLKC_CENS0_SHIFT)
#define _CLKC_CLKC_CENS0_MASK			(_CLKC_CLKC_CENS0_MK(0x0001u))
#define _CLKC_CLKC_CENS0_CLR			(~(_CLKC_CLKC_CENS0_MASK))

#define _CLKC_CLKC_CFINS_SHIFT		(0)
#define _CLKC_CLKC_CFINS_MK(n)		((Uint16)(n) & 0x0001u) 
#define _CLKC_CLKC_CFINS_MASK			(_CLKC_CLKC_CFINS_MK(0x0001u))
#define _CLKC_CLKC_CFINS_CLR			(~(_CLKC_CLKC_CFINS_MASK))



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

#define _CLKC_SEL_GET()			_REG_GET(_CLKC_SEL_ADDR)
#define _CLKC_SEL_SET(Val)			_REG_SET(_CLKC_SEL_ADDR, Val)
#define _CLKC_SEL_AOI(AND,OR,INV)		_REG_AOI(_CLKC_SEL_ADDR,AND,OR,INV)
#define _CLKC_SEL_FGET(Field)			_FIELD_GET(_CLKC_SEL_ADDR, _CLKC_SEL_##Field##)
#define _CLKC_SEL_FSET(Field, Val)		_FIELD_SET(_CLKC_SEL_ADDR, _CLKC_SEL_##Field##, Val)
#define _CLKC_SEL_FAOI(Field, AND, OR, INV)	_FIELD_AOI(_CLKC_SEL_ADDR, _CLKC_SEL_##Field##, AND, OR, INV)

#define _CLKC_SEL_CAXLS_SHIFT		(12)
#define _CLKC_SEL_CAXLS_MK(n)		(((Uint16)(n) & 0x0001u) << _CLKC_SEL_CAXLS_SHIFT)
#define _CLKC_SEL_CAXLS_MASK			(_CLKC_SEL_CAXLS_MK(0x0001u))
#define _CLKC_SEL_CAXLS_CLR			(~(_CLKC_SEL_CAXLS_MASK))

#define _CLKC_SEL_CSDRS_SHIFT		(8)
#define _CLKC_SEL_CSDRS_MK(n)		(((Uint16)(n) & 0x0001u) << _CLKC_SEL_CSDRS_SHIFT)
#define _CLKC_SEL_CSDRS_MASK			(_CLKC_SEL_CSDRS_MK(0x0001u))
#define _CLKC_SEL_CSDRS_CLR			(~(_CLKC_SEL_CSDRS_MASK))

#define _CLKC_SEL_CDSPS_SHIFT		(4)
#define _CLKC_SEL_CDSPS_MK(n)		(((Uint16)(n) & 0x0001u) << _CLKC_SEL_CDSPS_SHIFT)
#define _CLKC_SEL_CDSPS_MASK			(_CLKC_SEL_CDSPS_MK(0x0001u))
#define _CLKC_SEL_CDSPS_CLR			(~(_CLKC_SEL_CDSPS_MASK))

#define _CLKC_SEL_CARMS_SHIFT		(0)
#define _CLKC_SEL_CARMS_MK(n)		((Uint16)(n) & 0x0001u) 
#define _CLKC_SEL_CARMS_MASK			(_CLKC_SEL_CARMS_MK(0x0001u))
#define _CLKC_SEL_CARMS_CLR			(~(_CLKC_SEL_CARMS_MASK))



/*------------------------------------------------------------------------------*