csl_osdhal_270.h

dm270 source code

#define _OSD_VIDWINADH_SET(Val)			_REG_SET(_OSD_VIDWINADH_ADDR, Val)
#define _OSD_VIDWINADH_AOI(AND,OR,INV)		_REG_AOI(_OSD_VIDWINADH_ADDR,AND,OR,INV)
#define _OSD_VIDWINADH_FGET(Field)			_FIELD_GET(_OSD_VIDWINADH_ADDR, _OSD_VIDWINADH_##Field##)
#define _OSD_VIDWINADH_FSET(Field, Val)		_FIELD_SET(_OSD_VIDWINADH_ADDR, _OSD_VIDWINADH_##Field##, Val)
#define _OSD_VIDWINADH_FAOI(Field, AND, OR, INV)	_FIELD_AOI(_OSD_VIDWINADH_ADDR, _OSD_VIDWINADH_##Field##, AND, OR, INV)

#define _OSD_VIDWINADH_V1AH_SHIFT		(8)
#define _OSD_VIDWINADH_V1AH_MK(n)		(((Uint16)(n) & 0x003fu) << _OSD_VIDWINADH_V1AH_SHIFT)
#define _OSD_VIDWINADH_V1AH_MASK			(_OSD_VIDWINADH_V1AH_MK(0x003fu))
#define _OSD_VIDWINADH_V1AH_CLR			(~(_OSD_VIDWINADH_V1AH_MASK))

#define _OSD_VIDWINADH_V0AH_SHIFT		(0)
#define _OSD_VIDWINADH_V0AH_MK(n)		((Uint16)(n) & 0x003fu) 
#define _OSD_VIDWINADH_V0AH_MASK			(_OSD_VIDWINADH_V0AH_MK(0x003fu))
#define _OSD_VIDWINADH_V0AH_CLR			(~(_OSD_VIDWINADH_V0AH_MASK))



/*------------------------------------------------------------------------------*
* Register Macros for OSD VIDWIN0ADL register :
*                                                                                    
*                                                                                    
*                                                                                    
*---------------------------------------------------------------------------------*/

#define _OSD_VIDWIN0ADL_GET()			_REG_GET(_OSD_VIDWIN0ADL_ADDR)
#define _OSD_VIDWIN0ADL_SET(Val)			_REG_SET(_OSD_VIDWIN0ADL_ADDR, Val)
#define _OSD_VIDWIN0ADL_AOI(AND,OR,INV)		_REG_AOI(_OSD_VIDWIN0ADL_ADDR,AND,OR,INV)



/*------------------------------------------------------------------------------*
* Register Macros for OSD VIDWIN1ADL register :
*                                                                                    
*                                                                                    
*                                                                                    
*---------------------------------------------------------------------------------*/

#define _OSD_VIDWIN1ADL_GET()			_REG_GET(_OSD_VIDWIN1ADL_ADDR)
#define _OSD_VIDWIN1ADL_SET(Val)			_REG_SET(_OSD_VIDWIN1ADL_ADDR, Val)
#define _OSD_VIDWIN1ADL_AOI(AND,OR,INV)		_REG_AOI(_OSD_VIDWIN1ADL_ADDR,AND,OR,INV)



/*------------------------------------------------------------------------------*
* Register Macros for OSD OSDWINADH register :
*                                                                                    
*                                                                                    
*                                                                                    
*---------------------------------------------------------------------------------*/

#define _OSD_OSDWINADH_GET()			_REG_GET(_OSD_OSDWINADH_ADDR)
#define _OSD_OSDWINADH_SET(Val)			_REG_SET(_OSD_OSDWINADH_ADDR, Val)
#define _OSD_OSDWINADH_AOI(AND,OR,INV)		_REG_AOI(_OSD_OSDWINADH_ADDR,AND,OR,INV)
#define _OSD_OSDWINADH_FGET(Field)			_FIELD_GET(_OSD_OSDWINADH_ADDR, _OSD_OSDWINADH_##Field##)
#define _OSD_OSDWINADH_FSET(Field, Val)		_FIELD_SET(_OSD_OSDWINADH_ADDR, _OSD_OSDWINADH_##Field##, Val)
#define _OSD_OSDWINADH_FAOI(Field, AND, OR, INV)	_FIELD_AOI(_OSD_OSDWINADH_ADDR, _OSD_OSDWINADH_##Field##, AND, OR, INV)

#define _OSD_OSDWINADH_O1AH_SHIFT		(8)
#define _OSD_OSDWINADH_O1AH_MK(n)		(((Uint16)(n) & 0x003fu) << _OSD_OSDWINADH_O1AH_SHIFT)
#define _OSD_OSDWINADH_O1AH_MASK			(_OSD_OSDWINADH_O1AH_MK(0x003fu))
#define _OSD_OSDWINADH_O1AH_CLR			(~(_OSD_OSDWINADH_O1AH_MASK))

#define _OSD_OSDWINADH_O0AH_SHIFT		(0)
#define _OSD_OSDWINADH_O0AH_MK(n)		((Uint16)(n) & 0x003fu) 
#define _OSD_OSDWINADH_O0AH_MASK			(_OSD_OSDWINADH_O0AH_MK(0x003fu))
#define _OSD_OSDWINADH_O0AH_CLR			(~(_OSD_OSDWINADH_O0AH_MASK))



/*------------------------------------------------------------------------------*
* Register Macros for OSD OSDWIN0ADL register :
*                                                                                    
*                                                                                    
*                                                                                    
*---------------------------------------------------------------------------------*/

#define _OSD_OSDWIN0ADL_GET()			_REG_GET(_OSD_OSDWIN0ADL_ADDR)
#define _OSD_OSDWIN0ADL_SET(Val)			_REG_SET(_OSD_OSDWIN0ADL_ADDR, Val)
#define _OSD_OSDWIN0ADL_AOI(AND,OR,INV)		_REG_AOI(_OSD_OSDWIN0ADL_ADDR,AND,OR,INV)



/*------------------------------------------------------------------------------*
* Register Macros for OSD OSDWIN1ADL register :
*                                                                                    
*                                                                                    
*                                                                                    
*---------------------------------------------------------------------------------*/

#define _OSD_OSDWIN1ADL_GET()			_REG_GET(_OSD_OSDWIN1ADL_ADDR)
#define _OSD_OSDWIN1ADL_SET(Val)			_REG_SET(_OSD_OSDWIN1ADL_ADDR, Val)
#define _OSD_OSDWIN1ADL_AOI(AND,OR,INV)		_REG_AOI(_OSD_OSDWIN1ADL_ADDR,AND,OR,INV)



/*------------------------------------------------------------------------------*
* Register Macros for OSD BASEPX register :
*                                                                                    
*                                                                                    
*                                                                                    
*---------------------------------------------------------------------------------*/

#define _OSD_BASEPX_GET()			_REG_GET(_OSD_BASEPX_ADDR)
#define _OSD_BASEPX_SET(Val)			_REG_SET(_OSD_BASEPX_ADDR, Val)
#define _OSD_BASEPX_AOI(AND,OR,INV)		_REG_AOI(_OSD_BASEPX_ADDR,AND,OR,INV)
#define _OSD_BASEPX_FGET(Field)			_FIELD_GET(_OSD_BASEPX_ADDR, _OSD_BASEPX_##Field##)
#define _OSD_BASEPX_FSET(Field, Val)		_FIELD_SET(_OSD_BASEPX_ADDR, _OSD_BASEPX_##Field##, Val)
#define _OSD_BASEPX_FAOI(Field, AND, OR, INV)	_FIELD_AOI(_OSD_BASEPX_ADDR, _OSD_BASEPX_##Field##, AND, OR, INV)

#define _OSD_BASEPX_BPX_SHIFT		(0)
#define _OSD_BASEPX_BPX_MK(n)		((Uint16)(n) & 0x03ffu) 
#define _OSD_BASEPX_BPX_MASK			(_OSD_BASEPX_BPX_MK(0x03ffu))
#define _OSD_BASEPX_BPX_CLR			(~(_OSD_BASEPX_BPX_MASK))



/*------------------------------------------------------------------------------*
* Register Macros for OSD BASEPY register :
*                                                                                    
*                                                                                    
*                                                                                    
*---------------------------------------------------------------------------------*/

#define _OSD_BASEPY_GET()			_REG_GET(_OSD_BASEPY_ADDR)
#define _OSD_BASEPY_SET(Val)			_REG_SET(_OSD_BASEPY_ADDR, Val)
#define _OSD_BASEPY_AOI(AND,OR,INV)		_REG_AOI(_OSD_BASEPY_ADDR,AND,OR,INV)
#define _OSD_BASEPY_FGET(Field)			_FIELD_GET(_OSD_BASEPY_ADDR, _OSD_BASEPY_##Field##)
#define _OSD_BASEPY_FSET(Field, Val)		_FIELD_SET(_OSD_BASEPY_ADDR, _OSD_BASEPY_##Field##, Val)
#define _OSD_BASEPY_FAOI(Field, AND, OR, INV)	_FIELD_AOI(_OSD_BASEPY_ADDR, _OSD_BASEPY_##Field##, AND, OR, INV)

#define _OSD_BASEPY_BPY_SHIFT		(0)
#define _OSD_BASEPY_BPY_MK(n)		((Uint16)(n) & 0x01ffu) 
#define _OSD_BASEPY_BPY_MASK			(_OSD_BASEPY_BPY_MK(0x01ffu))
#define _OSD_BASEPY_BPY_CLR			(~(_OSD_BASEPY_BPY_MASK))



/*------------------------------------------------------------------------------*
* Register Macros for OSD VIDWIN0XP register :
*                                                                                    
*                                                                                    
*                                                                                    
*---------------------------------------------------------------------------------*/

#define _OSD_VIDWIN0XP_GET()			_REG_GET(_OSD_VIDWIN0XP_ADDR)
#define _OSD_VIDWIN0XP_SET(Val)			_REG_SET(_OSD_VIDWIN0XP_ADDR, Val)
#define _OSD_VIDWIN0XP_AOI(AND,OR,INV)		_REG_AOI(_OSD_VIDWIN0XP_ADDR,AND,OR,INV)
#define _OSD_VIDWIN0XP_FGET(Field)			_FIELD_GET(_OSD_VIDWIN0XP_ADDR, _OSD_VIDWIN0XP_##Field##)
#define _OSD_VIDWIN0XP_FSET(Field, Val)		_FIELD_SET(_OSD_VIDWIN0XP_ADDR, _OSD_VIDWIN0XP_##Field##, Val)
#define _OSD_VIDWIN0XP_FAOI(Field, AND, OR, INV)	_FIELD_AOI(_OSD_VIDWIN0XP_ADDR, _OSD_VIDWIN0XP_##Field##, AND, OR, INV)

#define _OSD_VIDWIN0XP_V0X_SHIFT		(0)
#define _OSD_VIDWIN0XP_V0X_MK(n)		((Uint16)(n) & 0x03ffu) 
#define _OSD_VIDWIN0XP_V0X_MASK			(_OSD_VIDWIN0XP_V0X_MK(0x03ffu))
#define _OSD_VIDWIN0XP_V0X_CLR			(~(_OSD_VIDWIN0XP_V0X_MASK))



/*------------------------------------------------------------------------------*
* Register Macros for OSD VIDWIN0YP register :
*                                                                                    
*                                                                                    
*                                                                                    
*---------------------------------------------------------------------------------*/

#define _OSD_VIDWIN0YP_GET()			_REG_GET(_OSD_VIDWIN0YP_ADDR)
#define _OSD_VIDWIN0YP_SET(Val)			_REG_SET(_OSD_VIDWIN0YP_ADDR, Val)
#define _OSD_VIDWIN0YP_AOI(AND,OR,INV)		_REG_AOI(_OSD_VIDWIN0YP_ADDR,AND,OR,INV)
#define _OSD_VIDWIN0YP_FGET(Field)			_FIELD_GET(_OSD_VIDWIN0YP_ADDR, _OSD_VIDWIN0YP_##Field##)
#define _OSD_VIDWIN0YP_FSET(Field, Val)		_FIELD_SET(_OSD_VIDWIN0YP_ADDR, _OSD_VIDWIN0YP_##Field##, Val)
#define _OSD_VIDWIN0YP_FAOI(Field, AND, OR, INV)	_FIELD_AOI(_OSD_VIDWIN0YP_ADDR, _OSD_VIDWIN0YP_##Field##, AND, OR, INV)

#define _OSD_VIDWIN0YP_V0Y_SHIFT		(0)
#define _OSD_VIDWIN0YP_V0Y_MK(n)		((Uint16)(n) & 0x01ffu) 
#define _OSD_VIDWIN0YP_V0Y_MASK			(_OSD_VIDWIN0YP_V0Y_MK(0x01ffu))
#define _OSD_VIDWIN0YP_V0Y_CLR			(~(_OSD_VIDWIN0YP_V0Y_MASK))



/*------------------------------------------------------------------------------*
* Register Macros for OSD VIDWIN0XL register :
*                                                                                    
*                                                                                    
*                                                                                    
*---------------------------------------------------------------------------------*/

#define _OSD_VIDWIN0XL_GET()			_REG_GET(_OSD_VIDWIN0XL_ADDR)
#define _OSD_VIDWIN0XL_SET(Val)			_REG_SET(_OSD_VIDWIN0XL_ADDR, Val)
#define _OSD_VIDWIN0XL_AOI(AND,OR,INV)		_REG_AOI(_OSD_VIDWIN0XL_ADDR,AND,OR,INV)
#define _OSD_VIDWIN0XL_FGET(Field)			_FIELD_GET(_OSD_VIDWIN0XL_ADDR, _OSD_VIDWIN0XL_##Field##)
#define _OSD_VIDWIN0XL_FSET(Field, Val)		_FIELD_SET(_OSD_VIDWIN0XL_ADDR, _OSD_VIDWIN0XL_##Field##, Val)
#define _OSD_VIDWIN0XL_FAOI(Field, AND, OR, INV)	_FIELD_AOI(_OSD_VIDWIN0XL_ADDR, _OSD_VIDWIN0XL_##Field##, AND, OR, INV)

#define _OSD_VIDWIN0XL_V0W_SHIFT		(0)
#define _OSD_VIDWIN0XL_V0W_MK(n)		((Uint16)(n) & 0x0fffu) 
#define _OSD_VIDWIN0XL_V0W_MASK			(_OSD_VIDWIN0XL_V0W_MK(0x0fffu))
#define _OSD_VIDWIN0XL_V0W_CLR			(~(_OSD_VIDWIN0XL_V0W_MASK))



/*------------------------------------------------------------------------------*
* Register Macros for OSD VIDWIN0YL register :
*                                                                                    
*                                                                                    
*                                                                                    
*---------------------------------------------------------------------------------*/

#define _OSD_VIDWIN0YL_GET()			_REG_GET(_OSD_VIDWIN0YL_ADDR)
#define _OSD_VIDWIN0YL_SET(Val)			_REG_SET(_OSD_VIDWIN0YL_ADDR, Val)
#define _OSD_VIDWIN0YL_AOI(AND,OR,INV)		_REG_AOI(_OSD_VIDWIN0YL_ADDR,AND,OR,INV)
#define _OSD_VIDWIN0YL_FGET(Field)			_FIELD_GET(_OSD_VIDWIN0YL_ADDR, _OSD_VIDWIN0YL_##Field##)
#define _OSD_VIDWIN0YL_FSET(Field, Val)		_FIELD_SET(_OSD_VIDWIN0YL_ADDR, _OSD_VIDWIN0YL_##Field##, Val)
#define _OSD_VIDWIN0YL_FAOI(Field, AND, OR, INV)	_FIELD_AOI(_OSD_VIDWIN0YL_ADDR, _OSD_VIDWIN0YL_##Field##, AND, OR, INV)

#define _OSD_VIDWIN0YL_V0H_SHIFT		(0)
#define _OSD_VIDWIN0YL_V0H_MK(n)		((Uint16)(n) & 0x07ffu) 
#define _OSD_VIDWIN0YL_V0H_MASK			(_OSD_VIDWIN0YL_V0H_MK(0x07ffu))
#define _OSD_VIDWIN0YL_V0H_CLR			(~(_OSD_VIDWIN0YL_V0H_MASK))



/*------------------------------------------------------------------------------*
* Register Macros for OSD VIDWIN1XP register :
*                                                                                    
*                                                                                    
*                                                                                    
*---------------------------------------------------------------------------------*/

#define _OSD_VIDWIN1XP_GET()			_REG_GET(_OSD_VIDWIN1XP_ADDR)
#define _OSD_VIDWIN1XP_SET(Val)			_REG_SET(_OSD_VIDWIN1XP_ADDR, Val)
#define _OSD_VIDWIN1XP_AOI(AND,OR,INV)		_REG_AOI(_OSD_VIDWIN1XP_ADDR,AND,OR,INV)
#define _OSD_VIDWIN1XP_FGET(Field)			_FIELD_GET(_OSD_VIDWIN1XP_ADDR, _OSD_VIDWIN1XP_##Field##)
#define _OSD_VIDWIN1XP_FSET(Field, Val)		_FIELD_SET(_OSD_VIDWIN1XP_ADDR, _OSD_VIDWIN1XP_##Field##, Val)