perfrag.c

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

	bValidUnit = PF_UNIT_VALID(unit);
	//nUnitEnableVal =0;

	if(bValidUnit)
	{
		switch(unit)
		{
		default:
		case FGL_PF_SCISSOR: 
			READREGP(FGPF_SCISSOR_XCORD, nUnitEnableVal);
			FGL_SET_BITFIELD(nUnitEnableVal, 31:31, enable);
			WRITEREG(FGPF_SCISSOR_XCORD, nUnitEnableVal);
			break;
		case FGL_PF_ALPHA: 
			READREGP(FGPF_ALPHA, nUnitEnableVal);
			FGL_SET_BITFIELD(nUnitEnableVal, 0:0, enable);
			WRITEREG(FGPF_ALPHA, nUnitEnableVal);
			break;
		case FGL_PF_STENCIL: 
			READREGP(FGPF_FRONTFACE_STENCIL, nUnitEnableVal);
			FGL_SET_BITFIELD(nUnitEnableVal, 0:0, enable);
			WRITEREG(FGPF_FRONTFACE_STENCIL, nUnitEnableVal);
			break;
		case FGL_PF_DEPTH: 
			READREGP(FGPF_DEPTH, nUnitEnableVal);
			FGL_SET_BITFIELD(nUnitEnableVal, 0:0, enable);
			WRITEREG(FGPF_DEPTH, nUnitEnableVal);
			break;
		case FGL_PF_BLENDING: 
			READREGP(FGPF_BLEND, nUnitEnableVal);
			FGL_SET_BITFIELD(nUnitEnableVal, 0:0, enable);
			WRITEREG(FGPF_BLEND, nUnitEnableVal);
			break;
		case FGL_PF_LOGICALOP: 
			READREGP(FGPF_LOGIC_OP, nUnitEnableVal);
			FGL_SET_BITFIELD(nUnitEnableVal, 0:0, enable);
			WRITEREG(FGPF_LOGIC_OP, nUnitEnableVal);
			break;
		}
		
		ret = FGL_ERR_NO_ERROR;
	}
	else
	{
		//printf((DBG_ERROR, "Cannot set enable per-fragment units - invalid unit."));
		ret = FGL_ERR_INVALID_PARAMETER;
	}
	
	return ret;	
}

/***************************************************************************** 
 * FUNCTIONS: fglSetScissorParams
 * SYNOPSIS: This function specifies an arbitary screen-aligned rectangle 
 *           outside of which fragments will be discarded.  
 * PARAMETERS: [IN] xMax: the maximum x coordinates of scissor box.
 *             [IN] xMin: the minimum x coordinates of scissor box.
 *             [IN] yMax: the maximum y coordiantes of scissor box.
 *             [IN] yMin: the minimum y coordinates of scissor box.
 * RETURNS: FGL_ERR_NO_ERROR - if successful.
 *          FGL_ERR_INVALID_VALUE - either x or y coordinates was not an 
 *                                  accepted value.
 * ERRNO:   FGL_ERR_NO_ERROR            1	    
 *          FGL_ERR_INVALID_VALUE       7	
 *****************************************************************************/
FGL_Error 
fglSetScissorParams ( 
						unsigned int xMax, 
						unsigned int xMin,
   						unsigned int yMax, 
   						unsigned int yMin
   					)
{
	FGL_Error ret = FGL_ERR_UNKNOWN;
	FGL_BOOL bValidXCoord = FGL_FALSE;
	FGL_BOOL bValidYCoord = FGL_FALSE;
	
	unsigned int nScissorXVal =0;
	unsigned int nScissorYVal =0;
	
	bValidXCoord = SCISSOR_REF_VALUE_VALID(xMax) && SCISSOR_REF_VALUE_VALID(xMin) && (xMax >= xMin);
	bValidYCoord = SCISSOR_REF_VALUE_VALID(yMax) && SCISSOR_REF_VALUE_VALID(yMin) && (yMax >= yMin);

	if (bValidXCoord && bValidYCoord)
	{
		READREGP(FGPF_SCISSOR_XCORD, nScissorXVal);
		FGL_SET_BITFIELD(nScissorXVal, 27:16, xMax);
		FGL_SET_BITFIELD(nScissorXVal, 11:0, xMin);
		WRITEREG(FGPF_SCISSOR_XCORD, nScissorXVal);
		
		FGL_SET_BITFIELD(nScissorYVal, 27:16, yMax);
		FGL_SET_BITFIELD(nScissorYVal, 11:0, yMin);
		WRITEREG(FGPF_SCISSOR_YCORD, nScissorYVal);

		ret = FGL_ERR_NO_ERROR;
	}
	else
	{
		if(!bValidXCoord)
		{
			//printf((DBG_ERROR, "Cannot set scissor test value - invalid x coordinate value"));
		}
		
		if(!bValidYCoord)
		{
			//printf((DBG_ERROR, "Cannot set scissor test value - invalid Y coordinate value"));
		}

		ret = FGL_ERR_INVALID_VALUE;
		
	}

	return ret;
}


/***************************************************************************** 
 * FUNCTIONS: fglSetAlphaParams
 * SYNOPSIS: This function discards a fragment depending on the outcome of a 
 *           comparison between the fragment's alpha value and a constant 
 *           reference value.
 * PARAMETERS:[IN] refAlpha: The reference value to which incoming alpha values
 *                 are compared. This value is clamped to the range 8bit value.
 *            [IN] mode: The alpha comparison function.
 * RETURNS: FGL_ERR_NO_ERROR - if successful.
 *          FGL_ERR_INVALID_VALUE - refAlpha was not an accepted value
 *          FGL_ERR_INVALID_PARAMETER - mode was not an accepted enum value
 * ERRNO:   FGL_ERR_NO_ERROR            1	    
 *          FGL_ERR_INVALID_PARAMETER   2
 *          FGL_ERR_INVALID_VALUE       7	
 *****************************************************************************/
FGL_Error 
fglSetAlphaParams ( unsigned int refAlpha, FGL_CompareFunc mode )
{
	FGL_BOOL bValidAlphaRef = FGL_FALSE;
	FGL_BOOL bValidCompareFunc = FGL_FALSE;
	unsigned int nAlphaVal =0;
	
	bValidAlphaRef = ALPHA_REF_VALUE_VALID(refAlpha);
	bValidCompareFunc = ALPHA_COMPARE_FUNC_VALID(mode);
		
	if (bValidAlphaRef && bValidCompareFunc)
	{
		READREGP(FGPF_ALPHA, nAlphaVal);
		FGL_SET_BITFIELD(nAlphaVal, 11:4, refAlpha);
		FGL_SET_BITFIELD(nAlphaVal, 3:1, mode);
		WRITEREG(FGPF_ALPHA, nAlphaVal);

		return FGL_ERR_NO_ERROR;
	}
	else
	{
		if(!bValidAlphaRef)
		{
			//printf((DBG_ERROR, "Cannot set alpha test control register - invalid reference value."));
			return FGL_ERR_INVALID_VALUE;
		}
		
		if(!bValidCompareFunc)
		{
			//printf((DBG_ERROR, "Cannot set alpha test control register - invalid parameters."));
			return FGL_ERR_INVALID_PARAMETER;
		}
	}
	return FGL_ERR_NO_ERROR;
}

/***************************************************************************** 
 * FUNCTIONS: fglSetStencilParams
 * SYNOPSIS: The stencil test conditionally discards a fragment based on the 
 *           outcome of a comparison between the value in the stencil buffer 
 *           and a reference value.
 * PARAMETERS: [IN] stencilParam: The point argument of FGL_StencilParam
 * RETURNS: FGL_ERR_NO_ERROR - if successful.
 *          FGL_ERR_INVALID_VALUE - The mask and ref of FGL_StencilParam was 
 *                                  not an accepted value .
 *          FGL_ERR_INVALID_PARAMETER - The zpass, zfail, sfail and mode of 
 *                                      FGL_StencilParam was not an accepted 
 *                                      enum value.
 * ERRNO:   FGL_ERR_NO_ERROR            1
 *          FGL_ERR_INVALID_PARAMETER   2
 *          FGL_ERR_INVALID_VALUE       7
 *****************************************************************************/
FGL_Error 
fglSetStencilParams ( pFGL_StencilParam stencilParam )
{
	FGL_BOOL bValidParam = FGL_FALSE;
	unsigned int nStencilVal = 0;
	unsigned int nFrontRegVal = 0;

    bValidParam = ( STENCIL_FACE_VALID(stencilParam->face) & STENCIL_OP_VALID(stencilParam->zpass) & 
                    STENCIL_OP_VALID(stencilParam->zfail) & STENCIL_OP_VALID(stencilParam->sfail) & 
                    STENCIL_MASK_VALID(stencilParam->mask) & STENCIL_REF_VALUE_VALID(stencilParam->ref) & 
                    STENCIL_COMPARE_FUNC_VALID(stencilParam->mode));

    if(bValidParam)
    {
		FGL_SET_BITFIELD(nStencilVal, 31:29, stencilParam->zpass);
		FGL_SET_BITFIELD(nStencilVal, 28:26, stencilParam->zfail);
		FGL_SET_BITFIELD(nStencilVal, 25:23, stencilParam->sfail);
		FGL_SET_BITFIELD(nStencilVal, 19:12, stencilParam->mask);
		FGL_SET_BITFIELD(nStencilVal, 11:4, stencilParam->ref);
		FGL_SET_BITFIELD(nStencilVal, 3:1, stencilParam->mode);

        switch((FGL_Face)(stencilParam->face))
        {
        case FGL_FACE_BACK:
		    WRITEREG(FGPF_BACKFACE_STENCIL, nStencilVal);
            break;
        case FGL_FACE_FRONT:
		    READREGP(FGPF_FRONTFACE_STENCIL, nFrontRegVal);
		    nStencilVal |= (nFrontRegVal & STENCIL_ENABLE_MASK);
		    WRITEREG(FGPF_FRONTFACE_STENCIL, nStencilVal);
            break;
        case FGL_FACE_FRONT_AND_BACK:
		    WRITEREG(FGPF_BACKFACE_STENCIL, nStencilVal);
		    READREGP(FGPF_FRONTFACE_STENCIL, nFrontRegVal);
		    nStencilVal |= (nFrontRegVal & STENCIL_ENABLE_MASK);
		    WRITEREG(FGPF_FRONTFACE_STENCIL, nStencilVal);
            break;
        default:
            return FGL_ERR_INVALID_PARAMETER;
        }
        
		return FGL_ERR_NO_ERROR;
	}
	else
	{
        return FGL_ERR_INVALID_PARAMETER;
	}
}

/***************************************************************************** 
 * FUNCTIONS: fglSetDepthParams
 * SYNOPSIS: This function specifies the value used for depth-buffer comparisons.
 * PARAMETERS: [IN] mode: Specifies the depth-comparison function
 * RETURNS: FGL_ERR_NO_ERROR - if successful.
 *          FGL_ERR_INVALID_PARAMETER - mode was not an accepted enum value.
 * ERRNO:   FGL_ERR_NO_ERROR            1
 *          FGL_ERR_INVALID_PARAMETER   2
 *****************************************************************************/
FGL_Error 
fglSetDepthParams ( FGL_CompareFunc mode )
{
	FGL_BOOL bValidCompFunc = FGL_FALSE;
	unsigned int nDepthVal =0;
	
	bValidCompFunc = DEPTH_COMPARE_FUNC_VALID(mode);
		
	if (bValidCompFunc)
	{
		READREGP(FGPF_DEPTH, nDepthVal);
		FGL_SET_BITFIELD(nDepthVal, 3:1, mode);
		WRITEREG(FGPF_DEPTH, nDepthVal);

		return FGL_ERR_NO_ERROR;
	}
	else
	{
		//printf((DBG_ERROR, "Cannot set depth test register - invalid parameters."));
		return FGL_ERR_INVALID_PARAMETER;
	}
}

/***************************************************************************** 
 * FUNCTIONS: fglSetBlendParams
 * SYNOPSIS: In RGB mode, pixels can be drawn using a function that blends 
 *           the incoming (source) RGBA values with the RGBA values that are 
 *           already in the framebuffer (the destination values). 
 * PARAMETERS: [in] blendParam - the pointer parameter of FGL_BlendParam
 * RETURNS: FGL_ERR_NO_ERROR - if successful
 *          FGL_ERR_INVALID_PARAMETER - the member of struct FGL_BlendParam  
 *                                      was not an accepted enum value.
 * ERRNO:   FGL_ERR_NO_ERROR            1
 *          FGL_ERR_INVALID_PARAMETER   2