csl_prevhal_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... PREV - HAL configuration module
* FILENAME...... /vobs/DSC_RTOS/arm/project/dm270/include/csl/csl_prevhal_270.h
* PROJECT....... ARM Chip Support Library
* COMPONENT..... HAL
* IMPORTS....... 
*------------------------------------------------------------------------------
* HISTORY:
*   CREATED:       12/06/2001 
*------------------------------------------------------------------------------
* DESCRIPTION:  (CHIP memory mapped register definitions)
*
*
*
\******************************************************************************/



/*-----------------------------------------------------------------------------------*
* Register Macros for PREV:
*------------------------------------------------------------------------------------*/


/*------------------------------------------------------------------------------*
* Register Macros for PREV PVEN register :
*                                                                                    
*                                                                                    
*                                                                                    
*---------------------------------------------------------------------------------*/

#define _PREV_PVEN_GET()			_REG_GET(_PREV_PVEN_ADDR)
#define _PREV_PVEN_SET(Val)			_REG_SET(_PREV_PVEN_ADDR, Val)
#define _PREV_PVEN_AOI(AND,OR,INV)		_REG_AOI(_PREV_PVEN_ADDR,AND,OR,INV)
#define _PREV_PVEN_FGET(Field)			_FIELD_GET(_PREV_PVEN_ADDR, _PREV_PVEN_##Field##)
#define _PREV_PVEN_FSET(Field, Val)		_FIELD_SET(_PREV_PVEN_ADDR, _PREV_PVEN_##Field##, Val)
#define _PREV_PVEN_FAOI(Field, AND, OR, INV)	_FIELD_AOI(_PREV_PVEN_ADDR, _PREV_PVEN_##Field##, AND, OR, INV)

#define _PREV_PVEN_PVEN_SHIFT		(0)
#define _PREV_PVEN_PVEN_MK(n)		((Uint16)(n) & 0x0001u) 
#define _PREV_PVEN_PVEN_MASK			(_PREV_PVEN_PVEN_MK(0x0001u))
#define _PREV_PVEN_PVEN_CLR			(~(_PREV_PVEN_PVEN_MASK))



/*------------------------------------------------------------------------------*
* Register Macros for PREV PVSET1 register :
*                                                                                    
*                                                                                    
*                                                                                    
*---------------------------------------------------------------------------------*/

#define _PREV_PVSET1_GET()			_REG_GET(_PREV_PVSET1_ADDR)
#define _PREV_PVSET1_SET(Val)			_REG_SET(_PREV_PVSET1_ADDR, Val)
#define _PREV_PVSET1_AOI(AND,OR,INV)		_REG_AOI(_PREV_PVSET1_ADDR,AND,OR,INV)
#define _PREV_PVSET1_FGET(Field)			_FIELD_GET(_PREV_PVSET1_ADDR, _PREV_PVSET1_##Field##)
#define _PREV_PVSET1_FSET(Field, Val)		_FIELD_SET(_PREV_PVSET1_ADDR, _PREV_PVSET1_##Field##, Val)
#define _PREV_PVSET1_FAOI(Field, AND, OR, INV)	_FIELD_AOI(_PREV_PVSET1_ADDR, _PREV_PVSET1_##Field##, AND, OR, INV)

#define _PREV_PVSET1_8BITS_SHIFT		(6)
#define _PREV_PVSET1_8BITS_MK(n)		(((Uint16)(n) & 0x0001u) << _PREV_PVSET1_8BITS_SHIFT)
#define _PREV_PVSET1_8BITS_MASK			(_PREV_PVSET1_8BITS_MK(0x0001u))
#define _PREV_PVSET1_8BITS_CLR			(~(_PREV_PVSET1_8BITS_MASK))

#define _PREV_PVSET1_ALAW_SHIFT		(5)
#define _PREV_PVSET1_ALAW_MK(n)		(((Uint16)(n) & 0x0001u) << _PREV_PVSET1_ALAW_SHIFT)
#define _PREV_PVSET1_ALAW_MASK			(_PREV_PVSET1_ALAW_MK(0x0001u))
#define _PREV_PVSET1_ALAW_CLR			(~(_PREV_PVSET1_ALAW_MASK))

#define _PREV_PVSET1_PVOS_SHIFT		(4)
#define _PREV_PVSET1_PVOS_MK(n)		(((Uint16)(n) & 0x0001u) << _PREV_PVSET1_PVOS_SHIFT)
#define _PREV_PVSET1_PVOS_MASK			(_PREV_PVSET1_PVOS_MK(0x0001u))
#define _PREV_PVSET1_PVOS_CLR			(~(_PREV_PVSET1_PVOS_MASK))

#define _PREV_PVSET1_RSONLY_SHIFT		(3)
#define _PREV_PVSET1_RSONLY_MK(n)		(((Uint16)(n) & 0x0001u) << _PREV_PVSET1_RSONLY_SHIFT)
#define _PREV_PVSET1_RSONLY_MASK			(_PREV_PVSET1_RSONLY_MK(0x0001u))
#define _PREV_PVSET1_RSONLY_CLR			(~(_PREV_PVSET1_RSONLY_MASK))

#define _PREV_PVSET1_INMODE_SHIFT		(2)
#define _PREV_PVSET1_INMODE_MK(n)		(((Uint16)(n) & 0x0001u) << _PREV_PVSET1_INMODE_SHIFT)
#define _PREV_PVSET1_INMODE_MASK			(_PREV_PVSET1_INMODE_MK(0x0001u))
#define _PREV_PVSET1_INMODE_CLR			(~(_PREV_PVSET1_INMODE_MASK))

#define _PREV_PVSET1_BSTAL_SHIFT		(1)
#define _PREV_PVSET1_BSTAL_MK(n)		(((Uint16)(n) & 0x0001u) << _PREV_PVSET1_BSTAL_SHIFT)
#define _PREV_PVSET1_BSTAL_MASK			(_PREV_PVSET1_BSTAL_MK(0x0001u))
#define _PREV_PVSET1_BSTAL_CLR			(~(_PREV_PVSET1_BSTAL_MASK))

#define _PREV_PVSET1_WEN_SHIFT		(0)
#define _PREV_PVSET1_WEN_MK(n)		((Uint16)(n) & 0x0001u) 
#define _PREV_PVSET1_WEN_MASK			(_PREV_PVSET1_WEN_MK(0x0001u))
#define _PREV_PVSET1_WEN_CLR			(~(_PREV_PVSET1_WEN_MASK))



/*------------------------------------------------------------------------------*
* Register Macros for PREV RADRH register :
*                                                                                    
*                                                                                    
*                                                                                    
*---------------------------------------------------------------------------------*/

#define _PREV_RADRH_GET()			_REG_GET(_PREV_RADRH_ADDR)
#define _PREV_RADRH_SET(Val)			_REG_SET(_PREV_RADRH_ADDR, Val)
#define _PREV_RADRH_AOI(AND,OR,INV)		_REG_AOI(_PREV_RADRH_ADDR,AND,OR,INV)
#define _PREV_RADRH_FGET(Field)			_FIELD_GET(_PREV_RADRH_ADDR, _PREV_RADRH_##Field##)
#define _PREV_RADRH_FSET(Field, Val)		_FIELD_SET(_PREV_RADRH_ADDR, _PREV_RADRH_##Field##, Val)
#define _PREV_RADRH_FAOI(Field, AND, OR, INV)	_FIELD_AOI(_PREV_RADRH_ADDR, _PREV_RADRH_##Field##, AND, OR, INV)

#define _PREV_RADRH_ADRH_SHIFT		(0)
#define _PREV_RADRH_ADRH_MK(n)		((Uint16)(n) & 0x003fu) 
#define _PREV_RADRH_ADRH_MASK			(_PREV_RADRH_ADRH_MK(0x003fu))
#define _PREV_RADRH_ADRH_CLR			(~(_PREV_RADRH_ADRH_MASK))



/*------------------------------------------------------------------------------*
* Register Macros for PREV RADRL register :
*                                                                                    
*                                                                                    
*                                                                                    
*---------------------------------------------------------------------------------*/

#define _PREV_RADRL_GET()			_REG_GET(_PREV_RADRL_ADDR)
#define _PREV_RADRL_SET(Val)			_REG_SET(_PREV_RADRL_ADDR, Val)
#define _PREV_RADRL_AOI(AND,OR,INV)		_REG_AOI(_PREV_RADRL_ADDR,AND,OR,INV)



/*------------------------------------------------------------------------------*
* Register Macros for PREV WADRH register :
*                                                                                    
*                                                                                    
*                                                                                    
*---------------------------------------------------------------------------------*/

#define _PREV_WADRH_GET()			_REG_GET(_PREV_WADRH_ADDR)
#define _PREV_WADRH_SET(Val)			_REG_SET(_PREV_WADRH_ADDR, Val)
#define _PREV_WADRH_AOI(AND,OR,INV)		_REG_AOI(_PREV_WADRH_ADDR,AND,OR,INV)
#define _PREV_WADRH_FGET(Field)			_FIELD_GET(_PREV_WADRH_ADDR, _PREV_WADRH_##Field##)
#define _PREV_WADRH_FSET(Field, Val)		_FIELD_SET(_PREV_WADRH_ADDR, _PREV_WADRH_##Field##, Val)
#define _PREV_WADRH_FAOI(Field, AND, OR, INV)	_FIELD_AOI(_PREV_WADRH_ADDR, _PREV_WADRH_##Field##, AND, OR, INV)

#define _PREV_WADRH_ADRH_SHIFT		(0)
#define _PREV_WADRH_ADRH_MK(n)		((Uint16)(n) & 0x003fu) 
#define _PREV_WADRH_ADRH_MASK			(_PREV_WADRH_ADRH_MK(0x003fu))
#define _PREV_WADRH_ADRH_CLR			(~(_PREV_WADRH_ADRH_MASK))



/*------------------------------------------------------------------------------*
* Register Macros for PREV WADRL register :
*                                                                                    
*                                                                                    
*                                                                                    
*---------------------------------------------------------------------------------*/

#define _PREV_WADRL_GET()			_REG_GET(_PREV_WADRL_ADDR)
#define _PREV_WADRL_SET(Val)			_REG_SET(_PREV_WADRL_ADDR, Val)
#define _PREV_WADRL_AOI(AND,OR,INV)		_REG_AOI(_PREV_WADRL_ADDR,AND,OR,INV)



/*------------------------------------------------------------------------------*
* Register Macros for PREV HSTART register :
*                                                                                    
*                                                                                    
*                                                                                    
*---------------------------------------------------------------------------------*/

#define _PREV_HSTART_GET()			_REG_GET(_PREV_HSTART_ADDR)
#define _PREV_HSTART_SET(Val)			_REG_SET(_PREV_HSTART_ADDR, Val)
#define _PREV_HSTART_AOI(AND,OR,INV)		_REG_AOI(_PREV_HSTART_ADDR,AND,OR,INV)
#define _PREV_HSTART_FGET(Field)			_FIELD_GET(_PREV_HSTART_ADDR, _PREV_HSTART_##Field##)
#define _PREV_HSTART_FSET(Field, Val)		_FIELD_SET(_PREV_HSTART_ADDR, _PREV_HSTART_##Field##, Val)
#define _PREV_HSTART_FAOI(Field, AND, OR, INV)	_FIELD_AOI(_PREV_HSTART_ADDR, _PREV_HSTART_##Field##, AND, OR, INV)

#define _PREV_HSTART_HSTRT_SHIFT		(0)
#define _PREV_HSTART_HSTRT_MK(n)		((Uint16)(n) & 0x0fffu) 
#define _PREV_HSTART_HSTRT_MASK			(_PREV_HSTART_HSTRT_MK(0x0fffu))
#define _PREV_HSTART_HSTRT_CLR			(~(_PREV_HSTART_HSTRT_MASK))



/*------------------------------------------------------------------------------*
* Register Macros for PREV HSIZE register :
*                                                                                    
*                                                                                    
*                                                                                    
*---------------------------------------------------------------------------------*/

#define _PREV_HSIZE_GET()			_REG_GET(_PREV_HSIZE_ADDR)
#define _PREV_HSIZE_SET(Val)			_REG_SET(_PREV_HSIZE_ADDR, Val)
#define _PREV_HSIZE_AOI(AND,OR,INV)		_REG_AOI(_PREV_HSIZE_ADDR,AND,OR,INV)
#define _PREV_HSIZE_FGET(Field)			_FIELD_GET(_PREV_HSIZE_ADDR, _PREV_HSIZE_##Field##)
#define _PREV_HSIZE_FSET(Field, Val)		_FIELD_SET(_PREV_HSIZE_ADDR, _PREV_HSIZE_##Field##, Val)
#define _PREV_HSIZE_FAOI(Field, AND, OR, INV)	_FIELD_AOI(_PREV_HSIZE_ADDR, _PREV_HSIZE_##Field##, AND, OR, INV)

#define _PREV_HSIZE_HSIZE_SHIFT		(0)
#define _PREV_HSIZE_HSIZE_MK(n)		((Uint16)(n) & 0x0fffu) 
#define _PREV_HSIZE_HSIZE_MASK			(_PREV_HSIZE_HSIZE_MK(0x0fffu))
#define _PREV_HSIZE_HSIZE_CLR			(~(_PREV_HSIZE_HSIZE_MASK))



/*------------------------------------------------------------------------------*
* Register Macros for PREV VSTART register :
*                                                                                    
*                                                                                    
*                                                                                    
*---------------------------------------------------------------------------------*/

#define _PREV_VSTART_GET()			_REG_GET(_PREV_VSTART_ADDR)
#define _PREV_VSTART_SET(Val)			_REG_SET(_PREV_VSTART_ADDR, Val)
#define _PREV_VSTART_AOI(AND,OR,INV)		_REG_AOI(_PREV_VSTART_ADDR,AND,OR,INV)
#define _PREV_VSTART_FGET(Field)			_FIELD_GET(_PREV_VSTART_ADDR, _PREV_VSTART_##Field##)
#define _PREV_VSTART_FSET(Field, Val)		_FIELD_SET(_PREV_VSTART_ADDR, _PREV_VSTART_##Field##, Val)
#define _PREV_VSTART_FAOI(Field, AND, OR, INV)	_FIELD_AOI(_PREV_VSTART_ADDR, _PREV_VSTART_##Field##, AND, OR, INV)

#define _PREV_VSTART_VSTRT_SHIFT		(0)
#define _PREV_VSTART_VSTRT_MK(n)		((Uint16)(n) & 0x0fffu) 
#define _PREV_VSTART_VSTRT_MASK			(_PREV_VSTART_VSTRT_MK(0x0fffu))
#define _PREV_VSTART_VSTRT_CLR			(~(_PREV_VSTART_VSTRT_MASK))



/*------------------------------------------------------------------------------*
* Register Macros for PREV VSIZE register :
*                                                                                    
*                                                                                    
*                                                                                    
*---------------------------------------------------------------------------------*/

#define _PREV_VSIZE_GET()			_REG_GET(_PREV_VSIZE_ADDR)
#define _PREV_VSIZE_SET(Val)			_REG_SET(_PREV_VSIZE_ADDR, Val)
#define _PREV_VSIZE_AOI(AND,OR,INV)		_REG_AOI(_PREV_VSIZE_ADDR,AND,OR,INV)
#define _PREV_VSIZE_FGET(Field)			_FIELD_GET(_PREV_VSIZE_ADDR, _PREV_VSIZE_##Field##)
#define _PREV_VSIZE_FSET(Field, Val)		_FIELD_SET(_PREV_VSIZE_ADDR, _PREV_VSIZE_##Field##, Val)
#define _PREV_VSIZE_FAOI(Field, AND, OR, INV)	_FIELD_AOI(_PREV_VSIZE_ADDR, _PREV_VSIZE_##Field##, AND, OR, INV)

#define _PREV_VSIZE_VSIZE_SHIFT		(0)
#define _PREV_VSIZE_VSIZE_MK(n)		((Uint16)(n) & 0x0fffu) 
#define _PREV_VSIZE_VSIZE_MASK			(_PREV_VSIZE_VSIZE_MK(0x0fffu))
#define _PREV_VSIZE_VSIZE_CLR			(~(_PREV_VSIZE_VSIZE_MASK))



/*------------------------------------------------------------------------------*
* Register Macros for PREV PVSET2 register :
*                                                                                    
*                                                                                    
*                                                                                    
*---------------------------------------------------------------------------------*/