texture.c

SMDK6410 Test Code Revision 02. s3c6410 official test code, shifting all the controller functional

fglSetTexMipmapLevel (
                                    unsigned int    unit,
	   			                    FGL_MipmapLevel level, 
	   			                    unsigned int    value
	   			               )
{
    unsigned int *pRegAddr = 0;

	if (((unsigned int)level > FGL_MIPMAP_MAX_LEVEL)
			|| (value > MAXVALUE_TU_MIPMAP_LEVEL))
	{
		return FGL_ERR_INVALID_VALUE;
	}

//	pRegAddr = (unsigned int *)(FGTU_TEX0_CTRL + unit * BITINTERVAL_TU_UNIT);

	switch(unit)
	{
	case 0:
		pRegAddr = (unsigned int *)((level==FGL_MIPMAP_MIN_LEVEL)?
					FGTU_TEX0_MIN_LEVEL:FGTU_TEX0_MAX_LEVEL);
		break;
	case 1:
		pRegAddr = (unsigned int *)((level==FGL_MIPMAP_MIN_LEVEL)?
					FGTU_TEX1_MIN_LEVEL:FGTU_TEX1_MAX_LEVEL);
		break;
	case 2:
		pRegAddr = (unsigned int *)((level==FGL_MIPMAP_MIN_LEVEL)?
					FGTU_TEX2_MIN_LEVEL:FGTU_TEX2_MAX_LEVEL);
		break;
	case 3:
		pRegAddr = (unsigned int *)((level==FGL_MIPMAP_MIN_LEVEL)?
					FGTU_TEX3_MIN_LEVEL:FGTU_TEX3_MAX_LEVEL);
		break;
	case 4:
		pRegAddr = (unsigned int *)((level==FGL_MIPMAP_MIN_LEVEL)?
					FGTU_TEX4_MIN_LEVEL:FGTU_TEX4_MAX_LEVEL);
		break;
	case 5:
		pRegAddr = (unsigned int *)((level==FGL_MIPMAP_MIN_LEVEL)?
					FGTU_TEX5_MIN_LEVEL:FGTU_TEX5_MAX_LEVEL);
		break;
	case 6:
		pRegAddr = (unsigned int *)((level==FGL_MIPMAP_MIN_LEVEL)?
					FGTU_TEX6_MIN_LEVEL:FGTU_TEX6_MAX_LEVEL);
		break;
	case 7:
		pRegAddr = (unsigned int *)((level==FGL_MIPMAP_MIN_LEVEL)?
					FGTU_TEX7_MIN_LEVEL:FGTU_TEX7_MAX_LEVEL);
		break;
	default:
		return FGL_ERR_INVALID_VALUE;
	}

	WRITEREG(pRegAddr, value);        
	return FGL_ERR_NO_ERROR;
       
}

/*****************************************************************************
 * FUNCTIONS: fglSetTexBaseAddr
 *
 * 			refer to
 * 			drvsys_write_reg(FGTU_TEX#_BASE_ADDR, unsigned int)
 *
 * SYNOPSIS: This function sets texture base address
 * 			 for each texture unit.
 * PARAMETERS: [IN]	unsigned int unit: texture unit ( 0~7 )
 * 			   [IN]	unsigned int addr: base address
 * RETURNS: FGL_ERR_NO_ERROR - if successful
 *          FGL_ERR_INVALID_VALUE - if specified unit is invalid
 * ERRNO: FGL_ERR_INVALID_VALUE = 7
 *****************************************************************************/
FGL_Error
fglSetTexBaseAddr(unsigned int unit, unsigned int addr)
{
    unsigned int *pTexRegBaseAddr;// = 0;

	switch(unit)
	{
	case 0:
		pTexRegBaseAddr = (unsigned int *)FGTU_TEX0_BASE_ADDR;
		break;
	case 1:
		pTexRegBaseAddr = (unsigned int *)FGTU_TEX1_BASE_ADDR;
		break;
	case 2:
		pTexRegBaseAddr = (unsigned int *)FGTU_TEX2_BASE_ADDR;
		break;
	case 3:
		pTexRegBaseAddr = (unsigned int *)FGTU_TEX3_BASE_ADDR;
		break;
	case 4:
		pTexRegBaseAddr = (unsigned int *)FGTU_TEX4_BASE_ADDR;
		break;
	case 5:
		pTexRegBaseAddr = (unsigned int *)FGTU_TEX5_BASE_ADDR;
		break;
	case 6:
		pTexRegBaseAddr = (unsigned int *)FGTU_TEX6_BASE_ADDR;
		break;
	case 7:
		pTexRegBaseAddr = (unsigned int *)FGTU_TEX7_BASE_ADDR;
		break;
	default:
		return FGL_ERR_INVALID_VALUE;   
	}

	WRITEREG(pTexRegBaseAddr, addr);        
	return FGL_ERR_NO_ERROR;
}

/*****************************************************************************
 * FUNCTIONS: fglSetTexColorKey
 *
 * 			refer to
 * 			drvsys_write_reg(FGTU_COLOR_KEY#, unsigned int)
 *
 * SYNOPSIS: This function sets 3D color key 1 or 2 register
 * PARAMETERS: [IN]	unsigned int unit: 3D color key register ( 0~1 )
 *			   [IN] FGL_TexCKey ckey: 3D color key value structure
 * 			 		 	typedef struct FGL_TexCKeyTag
 * 			 		 	{
 * 			 		 		unsigned char r;
 * 			 		 		unsigned char g;
 * 			 		 		unsigned char b;
 * 			 		 	} FGL_TexCKey;
 * RETURNS: FGL_ERR_NO_ERROR - if successful
 *          FGL_ERR_INVALID_VALUE - if specified unit is invalid
 * ERRNO: FGL_ERR_INVALID_VALUE = 7
 *****************************************************************************/
FGL_Error
fglSetTexColorKey(unsigned int unit, FGL_TexCKey ckey)
{

	unsigned int uR;
	unsigned int uG;
	unsigned int uB;

	unsigned int uPort;
	unsigned int uX;

	if (unit == 0)
	{
		uPort = FGTU_COLOR_KEY1;
	}
	else if (unit == 1)
	{
		uPort = FGTU_COLOR_KEY2;
	}
	else
	{
		return FGL_ERR_INVALID_VALUE;
	}
	uR = (unsigned int) ckey.r;
	uG = (unsigned int) ckey.g;
	uB = (unsigned int) ckey.b;

	uX = (uR << BITSHIFT_TU_CK_RED)
		| (uG << BITSHIFT_TU_CK_GREEN)
		| uB;

	WRITEREG(uPort, uX);

	return FGL_ERR_NO_ERROR;
}

/*****************************************************************************
 * FUNCTIONS: fglSetTexColorKeyYUV
 *
 * 			refer to
 * 			drvsys_write_reg(FGTU_TEX_COLOR_KEY_YUV, unsigned int)
 *
 * SYNOPSIS: This function sets 3D color key YUV register
 * PARAMETERS: [IN]	unsigned char g: color key green value
 * 			   [IN]	unsigned char b: color key blue value
 * RETURNS: FGL_ERR_NO_ERROR - It'll always succeed
 * ERRNO:
 *****************************************************************************/
FGL_Error
fglSetTexColorKeyYUV(unsigned char g, unsigned char b)
{
	unsigned int uG = (unsigned int)g;
	unsigned int uB = (unsigned int)b;

	WRITEREG(FGTU_COLOR_KEY_YUV, (uG << BITSHIFT_TU_CK_GREEN) | uB);
	return FGL_ERR_NO_ERROR;
}

/*****************************************************************************
 * FUNCTIONS: fglSetTexColorKeyMask
 *
 * 			refer to
 * 			drvsys_write_reg(FGTU_COLOR_KEY_MASK, unsigned int)
 *
 * SYNOPSIS: This function sets 3D color key mask register
 * PARAMETERS: [IN]	unsigned char bitsToMask: 3D color key mask value
 * RETURNS: FGL_ERR_NO_ERROR - if successful
 *          FGL_ERR_INVALID_VALUE - if specified mask is invalid
 * ERRNO: FGL_ERR_INVALID_VALUE = 7
 *****************************************************************************/
FGL_Error
fglSetTexColorKeyMask(unsigned char bitsToMask)
{
	if (bitsToMask > MAXVALUE_TU_CK_MASK)
	{
		return FGL_ERR_INVALID_VALUE;
	}

	WRITEREG(FGTU_COLOR_KEY_MASK, bitsToMask);

	return FGL_ERR_NO_ERROR;
}

/*****************************************************************************
 * FUNCTIONS: fglSetTexPaletteAddr
 *
 * 			refer to
 * 			drvsys_write_reg(FGTU_PALETTE_ADDR, unsigned int)
 *
 * SYNOPSIS: This function sets palette address for texturing
 * PARAMETERS: [IN]	unsigned int addr:  8-bit palette address
 * RETURNS: FGL_ERR_NO_ERROR - if successful
 *          FGL_ERR_INVALID_VALUE - if specified address is invalid
 * ERRNO: FGL_ERR_INVALID_VALUE = 7
 *****************************************************************************/
FGL_Error
fglSetTexPaletteAddr(unsigned int addr)
{
	if (addr > MAXVALUE_TU_PAL_ADDR)
	{
		return FGL_ERR_INVALID_VALUE;
	}

	WRITEREG(FGTU_PALETTE_ADDR, addr);

	return FGL_ERR_NO_ERROR;
}

/*****************************************************************************
 * FUNCTIONS: fglSetTexPaletteEntry
 *
 * 			refer to
 * 			drvsys_write_reg(FGTU_PALETTE_ENTRY, unsigned int)
 *
 * SYNOPSIS: This function sets palette entry for texturing
 * PARAMETERS: [IN]	unsigned int entry:  palette data in
 * RETURNS: FGL_ERR_NO_ERROR - It'll always succeed
 * ERRNO:
 *****************************************************************************/
FGL_Error
fglSetTexPaletteEntry(unsigned int entry)
{
	WRITEREG(FGTU_PALETTE_ENTRY, entry);

	return FGL_ERR_NO_ERROR;
}

/*****************************************************************************
 * FUNCTIONS: fglSetVtxTexUnitParams
 *
 * 			refer to
 * 			drvsys_write_reg(FGTU_VTXTEX#_CTRL, unsigned int)
 *
 * SYNOPSIS: This function sets vertex texture status register
 * 			 for each vertex texture unit.
 * PARAMETERS: [IN]	unsigned int unit: vertex texture unit ( 0~3 )
 *			   [IN] FGL_VtxTexStatusReg vts: vertex texture status structure
 * 			 		 	typedef struct FGL_VtxTexStatusRegTag
 * 			 		 	{
 * 			 		 		FGL_TexWrapMode uMode;
 * 			 		 		FGL_TexWrapMode vMode;
 * 			 		 		FGL_TexSize 	uSize;
 * 			 		 		FGL_TexSize 	vSize;
 * 			 		 	} FGL_VtxTexStatusReg;
 * RETURNS: FGL_ERR_NO_ERROR - if successful
 *          FGL_ERR_INVALID_SIZE - if vertex texture u or v size is invalid
 *          FGL_ERR_INVALID_VALUE - if specified unit or modes are invalid
 * ERRNO: FGL_ERR_INVALID_SIZE = 6
 * 		  FGL_ERR_INVALID_VALUE = 7
 *****************************************************************************/
FGL_Error
fglSetVtxTexUnitParams(unsigned int unit, FGL_VtxTexStatusReg *vts)
{
	unsigned int uUSize = (unsigned int)vts->uSize;
	unsigned int uVSize = (unsigned int)vts->vSize;

	unsigned int uUMode;
	unsigned int uVMode;

	unsigned int uPort;
	unsigned int uX;

	if ( (uUSize > FGL_TEX_SIZE_2048P) || (uVSize > FGL_TEX_SIZE_2048P) )
	{
		return FGL_ERR_INVALID_SIZE;
	}

	uUMode = (unsigned int)vts->uMode;
	uVMode = (unsigned int)vts->vMode;

	if ((uUMode > FGL_TEX_WRAP_CLAMP) || (uVMode > FGL_TEX_WRAP_CLAMP))
	{
		return FGL_ERR_INVALID_VALUE;
	}

	switch (unit)
	{
	case 0:
		uPort = FGTU_VTXTEX0_CTRL;
		break;
	case 1:
		uPort = FGTU_VTXTEX1_CTRL;
		break;
	case 2:
		uPort = FGTU_VTXTEX2_CTRL;
		break;
	case 3:
		uPort = FGTU_VTXTEX3_CTRL;
		break;
	default:
		return FGL_ERR_INVALID_VALUE;
	}

	uX = (uUMode << BITSHIFT_TU_VTX_UMODE)
		| (uVMode << BITSHIFT_TU_VTX_VMODE)
		| (uUSize << BITSHIFT_TU_VTX_USIZE)
		| uVSize;

	WRITEREG(uPort, uX);

	return FGL_ERR_NO_ERROR;
}


/*****************************************************************************
 * FUNCTIONS: fglSetVtxTexBaseAddr
 *
 * 			refer to
 * 			drvsys_write_reg(FGTU_TEX#_BASE_LEVEL, unsigned int)
 * 			drvsys_write_reg(FGTU_TEX#_MAX_LEVEL, unsigned int)
 *
 * SYNOPSIS: This function sets vertex texture base address
 * 			 for each vertex texture unit.
 * PARAMETERS: [IN]	unsigned int unit: vertex texture unit ( 0~3 )
 * 			   [IN]	unsigned int addr: vertex texture base address
 * RETURNS: FGL_ERR_NO_ERROR - if successful
 *          FGL_ERR_INVALID_VALUE - if specified unit is invalid
 * ERRNO: FGL_ERR_INVALID_VALUE = 7
 *****************************************************************************/
FGL_Error
fglSetVtxTexBaseAddr(unsigned int unit, unsigned int addr)
{
	unsigned int uPort;

	switch (unit)
	{
	case 0:
		uPort = FGTU_VTXTEX0_BASE_ADDR;
		break;
	case 1:
		uPort = FGTU_VTXTEX1_BASE_ADDR;
		break;
	case 2:
		uPort = FGTU_VTXTEX2_BASE_ADDR;
		break;
	case 3:
		uPort = FGTU_VTXTEX3_BASE_ADDR;
		break;
	default:
		return FGL_ERR_INVALID_VALUE;
	}

	WRITEREG(uPort, addr);

	return FGL_ERR_NO_ERROR;
}