shader.c

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

		pAddr = (unsigned int *)FGVS_IN_ATTRIB_IDX0;
		size = pShaderHeader->InTableSize;
		offset += size;

		while (size & 0xFFFFFFFC)
		{
			//AttribIdx = ((IdxVal++) | ((IdxVal++) << 8) | ((IdxVal++)<<16) | ((IdxVal++) << 24));
			AttribIdx |= (IdxVal++);
			AttribIdx |= ((IdxVal++) << 8);
			AttribIdx |= ((IdxVal++) << 16);
			AttribIdx |= ((IdxVal++) << 24);
			
			WRITEREG(pAddr++, AttribIdx);
			size -= 4;
			AttribIdx = 0;
		}

		for(i=0; i<size; i++)
		{
			AttribIdx |= (IdxVal++)<<(i*8);
		}

		//WRITEREG(pAddr++, AttribIdx);
		WRITEREG(pAddr++, 0x03020100);

		size = pShaderHeader->OutTableSize;
		offset += size;
		IdxVal = 0;

		while (size & 0xFFFFFFFC)
		{
			AttribIdx = ((IdxVal++) | ((IdxVal++) << 8) | ((IdxVal++)<<16) | ((IdxVal++) << 24));
			WRITEREG(pAddr++, AttribIdx);
			size -= 4;
			AttribIdx = 0;
	    }

		for(i=0; i<size; i++)
	    {
			AttribIdx |= (IdxVal++)<<(i*8);
		}

		WRITEREG(pAddr++, AttribIdx);
	}

	if(pShaderHeader->SamTableSize != 0)
	{
		// TODO
		offset += pShaderHeader->SamTableSize;
	}
	

	if(pShaderHeader->InstructSize != 0)
	{ 
		// vertex shader instruction memory start addr.
		pAddr = (unsigned int *)FGVS_INSTMEM_SADDR;
		pShaderData =(unsigned int *)(pShaderBody + offset);
		size = pShaderHeader->InstructSize;
		offset += size;

		if(PROGRAM_COUNT_VALUE_VALID(size))
		{
		// Program counter start/end address setting
			WRITEREG(FGVS_PC_RANGE, ((size >> 2) - 1) << PROGRAM_COUNT_END_SHIFT);
			WRITEREG(FGVS_CONFIG, PROGRAM_COUNT_COPYOUT); // PC_RANGE vlaue is copied to VS inside
			//drvsys_polling_mask(FGVS_CONFIG, 0x0, 0x1);
		}
		else
		{
			//printf((DBG_ERROR, "Cannot set vertex shader pc vlaue - invalid end pc value"));
			return FGL_ERR_INVALID_VALUE;
		}
		
		do
		{
			WRITEREG(pAddr++, *pShaderData++);
		} while(--size != 0);
	} 

	if(pShaderHeader->ConstFloatSize != 0)
	{ 
		// vertex shader float memory start addr.
		pAddr = (unsigned int *)FGVS_CFLOAT_SADDR;
		pShaderData =(unsigned int *)(pShaderBody + offset);
		size = pShaderHeader->ConstFloatSize;
		offset += size;

		do
		{
			WRITEREG(pAddr++, *pShaderData++);
		} while(--size != 0);
	} 

	if(pShaderHeader->ConstIntSize != 0)
	{ 
		// vertex shader integer memory start addr.
		pAddr = (unsigned int *)FGVS_CINT_SADDR;
		pShaderData =(unsigned int *)(pShaderBody + offset);
		size = pShaderHeader->ConstIntSize;
		offset += size;

		do
		{
			WRITEREG(pAddr++, *pShaderData++);
		} while(--size != 0);
	} 

	if(pShaderHeader->ConstBoolSize != 0)
	{ 
		pShaderData =(unsigned int *)(pShaderBody + offset);
		WRITEREG(FGVS_CBOOL_SADDR, *pShaderData);
	} 

	return FGL_ERR_NO_ERROR;
}

/*****************************************************************************
 * FUNCTIONS: fglLoadPShader
 * SYNOPSIS: this function uploads a fragment shader program to shader memory   
 *           such as constant integer, float and instruction.    
 * PARAMETERS: [in] pShaderCode - the pointer of fragment shader program.
 * RETURNS: FGL_ERR_NO_ERROR, if successful
 *          FGL_ERR_INVALID_VALUE - the program count exceeds the range of 512 slots
 *          FGL_ERR_INVALID_SHADER_CODE - either magic number or shader version  
 *                                        were not an accepted value.  
 * ERRNO:   FGL_ERR_NO_ERROR                1
 *          FGL_ERR_INVALID_VALUE           7
 *          FGL_ERR_INVALID_SHADER_CODE     8
 *****************************************************************************/
FGL_Error
fglLoadPShader (const unsigned int *pShaderCode )
{
	FGL_Error ret = FGL_ERR_UNKNOWN;
	FGL_BOOL bValidParam = FGL_FALSE;
	//unsigned int i;
	unsigned int size;
	unsigned int offset = 0;
	unsigned int uAttribNum = 0;
	unsigned int uInBufStatus = 0;
	volatile unsigned int *pAddr;
	volatile unsigned int *pShaderData;

	FGL_ShaderHeader *pShaderHeader = (FGL_ShaderHeader*)pShaderCode;
	unsigned int *pShaderBody = (unsigned int*)(&pShaderHeader[1]);


	if ((pShaderHeader->Magic != PIXEL_SHADER_MAGIC) || (pShaderHeader->Version != SHADER_VERSION))
	{
		return FGL_ERR_INVALID_SHADER_CODE;
	}

	uAttribNum = pShaderHeader->InTableSize;
	bValidParam = PS_MAX_ATTRIB_NUM_VALID(uAttribNum);
	
	if( bValidParam && (uAttribNum != FGL_ZERO) )
	{
		ret = _PSExecuteMode(FGL_HOST_ACCESS_MODE);

		if (ret != FGL_ERR_NO_ERROR)
		{
			//printf((DBG_ERROR, " _PSExecuteMode is fail. - invalid Execute maode parameter"));
			return ret;
		}

		WRITEREG(FGPS_ATTRIB_NUM, uAttribNum);

		do
		{
			fglPSGetInBufferStatus(&uInBufStatus);
		}
		while(INPUT_BUFFER_READY != uInBufStatus);

		ret = _PSExecuteMode(FGL_PS_EXECUTE_MODE);

		if (ret != FGL_ERR_NO_ERROR)
	    {
			//printf((DBG_ERROR, " _PSExecuteMode is fail. - invalid Execute maode parameter"));
			return ret;
		}

		offset += pShaderHeader->InTableSize;
	}

	if(pShaderHeader->OutTableSize != 0)
	{
		// TODO
		offset += pShaderHeader->OutTableSize;
	}

	if(pShaderHeader->SamTableSize != 0)
	{
		// TODO
		offset += pShaderHeader->SamTableSize;
	}
	

	
	if(pShaderHeader->InstructSize != 0)
	{ 
		// vertex shader instruction memory start addr.
		pAddr = (unsigned int *)FGPS_INSTMEM_SADDR;
		pShaderData =(unsigned int *)(pShaderBody + offset);
		size = pShaderHeader->InstructSize;
		offset += size;

		bValidParam = PROGRAM_COUNT_VALUE_VALID(size);

		if(bValidParam)
		{
			ret = _PSExecuteMode(FGL_HOST_ACCESS_MODE);
			
			if (ret != FGL_ERR_NO_ERROR)
			{
				//printf((DBG_ERROR, " _PSExecuteMode is fail. - invalid Execute maode parameter"));
				return ret;
			}

			WRITEREG(FGPS_PC_START, FGL_ZERO);
			WRITEREG(FGPS_PC_END, ((size >> 2) - 1));
			WRITEREG(FGPS_PC_COPY, PROGRAM_COUNT_COPYOUT);

			ret = _PSExecuteMode(FGL_PS_EXECUTE_MODE);

			if (ret != FGL_ERR_NO_ERROR)
			{
				//printf((DBG_ERROR, " _PSExecuteMode is fail. - invalid Execute maode parameter"));
				return ret;
			}

			ret = FGL_ERR_NO_ERROR;
		}
		else
		{
			//printf((DBG_ERROR, "Cannot set pixel shader pc vlaue - invalid end pc value"));
			ret = FGL_ERR_INVALID_VALUE;
		}

		do
		{
			WRITEREG(pAddr++, *pShaderData++);
		} while(--size != 0);

	} 

	if(pShaderHeader->ConstFloatSize != 0)
	{ 
		// vertex shader float memory start addr.
		pAddr = (unsigned int *)FGPS_CFLOAT_SADDR;
		pShaderData =(unsigned int *)(pShaderBody + offset);
		size = pShaderHeader->ConstFloatSize;
		offset += size;

		do
		{
			WRITEREG(pAddr++, *pShaderData++);
		} while(--size != 0);
	} 

	if(pShaderHeader->ConstIntSize != 0)
	{ 
		// vertex shader integer memory start addr.
		pAddr = (unsigned int *)FGPS_CINT_SADDR;
		pShaderData =(unsigned int *)(pShaderBody + offset);
		size = pShaderHeader->ConstIntSize;
		offset += size;

		do
		{
			WRITEREG(pAddr++, *pShaderData++);
		} while(--size != 0);
	} 

	if(pShaderHeader->ConstBoolSize != 0)
	{ 
		pShaderData =(unsigned int *)(pShaderBody + offset);
		WRITEREG(FGPS_CBOOL_SADDR, *pShaderData);
	}

	return FGL_ERR_NO_ERROR;
}


/*****************************************************************************
  INTERNAL FUNCTIONS
 *****************************************************************************/

static FGL_Error 
_PSExecuteMode (
					FGL_ExecuteMode exeMode
			   )
{
	FGL_Error ret = FGL_ERR_UNKNOWN;

	//if(exeMode == (FGL_ExecuteMode)READREG(FGPS_EXE_MODE))
	unsigned int uReadReg;
	READREGP(FGPS_EXE_MODE, uReadReg);
	if(exeMode == (FGL_ExecuteMode)uReadReg)
	{
		return FGL_ERR_NO_ERROR;
	}

	switch(exeMode)
	{
	case FGL_HOST_ACCESS_MODE:

		//if((READREG(FG_PIPELINE_STATUS) & PS_ISNOT_EMPTY_MASK) != FGL_ZERO)
		READREGP(FG_PIPELINE_STATUS, uReadReg);
		if((uReadReg & PS_ISNOT_EMPTY_MASK) != FGL_ZERO)
		{
			//printf((DBG_ERROR, "Pipeline status is not empty"));
			return FGL_ERR_STATUS_BUSY;
		}

		WRITEREG(FGPS_EXE_MODE, HOST_ACCESS_MODE);
		ret = FGL_ERR_NO_ERROR;
		break;

	case FGL_PS_EXECUTE_MODE:

		//if((READREG(FGPS_INBUF_STATUS) & PS_INBUF_STATUS_MASK) != FGL_ZERO)
		READREGP(FGPS_INBUF_STATUS, uReadReg);
		if((uReadReg & PS_INBUF_STATUS_MASK) != FGL_ZERO)
		{
			//printf((DBG_ERROR, "The input buffer of pixel shader is not ready);
			return FGL_ERR_STATUS_BUSY;
		}

		WRITEREG(FGPS_EXE_MODE, PS_EXECUTION_MODE);
		ret = FGL_ERR_NO_ERROR;
		break;

	default:
		//printf((DBG_ERROR, "Cannot set PS execute mode - invalid exeMode"));
		ret = FGL_ERR_INVALID_PARAMETER;
		break;
	}

	return ret;
}


static unsigned int 
_SearchAttribTable (
						unsigned int 		*pAttribTable,
						unsigned int		tableSize,
						FGL_DeclareAttrib	dclAttribName						
   				   )
{
	unsigned int i;
	
	if(pAttribTable != FGL_NULL)
	{
		for(i=0; i < tableSize; i++)
		{
			if(pAttribTable[i] == dclAttribName)
			{
				return i;	
			}
		}
	} 

	return FGL_ZERO;
}