post.c

提供S3C6400源例子代码.希望对大家有所帮助

//			sCh - POST structure base address
// Output : 	None
void POST_SetCLKVALUpdate(u32 uUpdate, POST *sCh)
{
	u32 uModeCtrlVal;
	PostInp32(POST_MODE_CTRL, uModeCtrlVal);
	uModeCtrlVal = (uModeCtrlVal & ~(1<<30)) | (uUpdate<<30);

	PostOutp32(POST_MODE_CTRL, uModeCtrlVal);
}



//////////
// Function Name : POST_IsProcessingDone
// Function Description : Check if the processing is done
// Input : 	sCh - POST structure base address
// Output : 	true - processing is done
//			false - processing is running
bool POST_IsProcessingDone(POST *sCh)
{
	u32 uModeCtrlVal;
	PostInp32(POST_START_VIDEO, uModeCtrlVal);
	return ((uModeCtrlVal&(POST_START))    ? false : true);
}


//////////
// Function Name : POST_ClearPending
// Function Description : Interrupt Pending Bit clear
// Input : 	sCh - POST structure base address
// Output : 	None
void POST_ClearPending(POST *sCh)
{
	//rb1004
	PostInp32(POST_MODE_CTRL, sCh->m_uModeRegValue);
	
	PostOutp32( POST_MODE_CTRL, sCh->m_uModeRegValue & ~POST_PENDING );
}


//////////
// Function Name : POST_IsPendingEnabled
// Function Description : Check whether the Pending bit is set or not
// Input : 	sCh - POST structure base address
// Output : 	true - Pending bit is set
//			false - Pending bit is clear
bool POST_IsPendingEnabled(POST *sCh)
{
	u32 uModeCtrl;

	PostInp32( POST_MODE_CTRL, uModeCtrl );

	if ( uModeCtrl & (POST_PENDING) )
		return true;
	else
		return false;
}

//////////
// Function Name : POST_SetNextFrameStAddr
// Function Description : Set the Next Frame DMA Start/End Address Register
// Input : 	uNxtSrcFrmSt - The Start Address of the next source frame
//			uNxtDstFrmSt - The Start Address of the next destination frame
//			sCh - POST structure base address
// Output : 	None
void POST_SetNextFrameStAddr(u32 uNxtSrcFrmSt, u32 uNxtDstFrmSt, POST *sCh) // DMA path
{
 	u32 uNxtSrcStY, uNxtSrcEndY;
	u32 uNxtSrcStCb, uNxtSrcEndCb, uNxtSrcStCr, uNxtSrcEndCr;
	u32 uNxtDstStRgb, uNxtDstEndRgb;
	u32 uOutNxtDstStCb, uOutNxtDstEndCb, uOutNxtDstStCr, uOutNxtDstEndCr;
	u32 uModeCtrl;

	uNxtSrcStY = uNxtSrcFrmSt + sCh->m_uStPosY;	//sCh->m_uStPosY = (uSrcFullWidth*uSrcStartY+uSrcStartX)*uPixelSzIn;
	uNxtSrcEndY = uNxtSrcStY + sCh->m_uEndPosY;	//sCh->m_uEndPosY = uSrcWidth*uSrcHeight*uPixelSzIn + uOffsetY*(uSrcHeight-1);
	
	if ( sCh->m_eSrcCSpace == YC420 )
	{
		uNxtSrcStCb = uNxtSrcFrmSt + sCh->m_uStPosCb;
		uNxtSrcEndCb = uNxtSrcStCb + sCh->m_uEndPosCb;
		uNxtSrcStCr = uNxtSrcFrmSt + sCh->m_uStPosCr;
		uNxtSrcEndCr = uNxtSrcStCr + sCh->m_uEndPosCr;
	}
	
	uNxtDstStRgb = uNxtDstFrmSt + sCh->m_uStPosRgb;
	uNxtDstEndRgb = uNxtDstStRgb + sCh->m_uEndPosRgb;
	
	if ( sCh->m_eDstCSpace  == YC420 )
	{
		uOutNxtDstStCb = uNxtDstFrmSt + sCh->m_uOutStPosCb;
		uOutNxtDstEndCb = uOutNxtDstStCb + sCh->m_uOutStPosCb;
		uOutNxtDstStCr = uNxtDstFrmSt + sCh->m_uOutStPosCr;
		uOutNxtDstEndCr = uOutNxtDstStCr + sCh->m_uOutStPosCr;
	}
	
	uModeCtrl=0;
	PostInp32(POST_MODE_CTRL_2, uModeCtrl);
	uModeCtrl |= (0x1<<4);
	PostOutp32(POST_MODE_CTRL_2, uModeCtrl); 	
	
	PostOutp32(NEXT_ADDR_START_Y, uNxtSrcStY);
	PostOutp32(NEXT_ADDR_END_Y, uNxtSrcEndY);
	if ( sCh->m_eSrcCSpace == YC420 )
	{
		PostOutp32(NEXT_ADDR_START_CB, uNxtSrcStCb);
		PostOutp32(NEXT_ADDR_END_CB, uNxtSrcEndCb);
		PostOutp32(NEXT_ADDR_START_CR, uNxtSrcStCr);
		PostOutp32(NEXT_ADDR_END_CR, uNxtSrcEndCr);
	}

	PostOutp32(NEXT_ADDR_START_RGB, uNxtDstStRgb);
	PostOutp32(NEXT_ADDR_END_RGB, uNxtDstEndRgb);
	if ( sCh->m_eDstCSpace  == YC420 )
	{
		PostOutp32(NEXT_ADDR_START_OUT_CB, uOutNxtDstStCb);
		PostOutp32(NEXT_ADDR_END_OUT_CB, uOutNxtDstEndCb);
		PostOutp32(NEXT_ADDR_START_OUT_CR, uOutNxtDstStCr);
		PostOutp32(NEXT_ADDR_END_OUT_CR, uOutNxtDstEndCr);
	}

	uModeCtrl &= ~(0x1<<4);
	PostOutp32(POST_MODE_CTRL_2, uModeCtrl);
}



void POST_SetFifoOutPath(SCALER_PATH ePath, POST *sCh)
{
	u32 uPostModeCtrl2;
	if(sCh->m_uBaseAddr == TVSCALER_BASE)
	{
		PostInp32( POST_MODE_CTRL_2, uPostModeCtrl2 );
		
		uPostModeCtrl2 = (uPostModeCtrl2&~(3<<5)) | (ePath<<5);
		PostOutp32( POST_MODE_CTRL_2, uPostModeCtrl2 );
	}
}

//////////
// Function Name : POST_DisableChangeNextFrame
// Function Description : Disable Address change(Next Address Change)
// Input : 	sCh - POST structure base address
// Output : 	None
void POST_DisableChangeNextFrame(POST *sCh)
{
	u32 uModeCtrl;
	
	PostInp32(POST_MODE_CTRL_2, uModeCtrl);
	uModeCtrl |= (0x1<<4);
	PostOutp32(POST_MODE_CTRL_2, uModeCtrl);
}


//////////
// Function Name : POST_StopProcessingOfFreeRun
// Function Description : Stop the Post Free-Run Mode
// Input : 	sCh - POST structure base address
// Output : 	None
void POST_StopProcessingOfFreeRun(POST *sCh)
{
	PostInp32(POST_MODE_CTRL, sCh->m_uModeRegValue);
	sCh->m_uModeRegValue &= ~(1<<14);
	
	PostOutp32(POST_MODE_CTRL, sCh->m_uModeRegValue);
}



//////////
// Function Name : POST_CheckAutoLoadEnable
// Function Description : Check the Post Auto-Load Enable bit
// Input : 	sCh - POST structure base address
// Output : 	None
bool POST_CheckAutoLoadEnable(POST *sCh)
{
	PostInp32(POST_MODE_CTRL, sCh->m_uModeRegValue);
	if(sCh->m_uModeRegValue & (1<<14))
		return TRUE;
	else
		return FALSE;
}


//////////
// Function Name : POST_SetInterlaceModeOnOff
// Function Description : Set the output scal method selection register only when FIFO mode
// Input : 	onoff - 1 : Interace scan
//				    0 : Progressive scan
//			sCh - POST structure base address
// Output : 	None
void POST_SetInterlaceModeOnOff(int onoff, POST *sCh)
{
	Assert(onoff == 0 || onoff == 1);

	PostInp32(POST_MODE_CTRL, sCh->m_uModeRegValue);

	if (onoff == 1)
		sCh->m_uModeRegValue |= (1<<12);
	else
		sCh->m_uModeRegValue &= ~(1<<12);

	PostOutp32(POST_MODE_CTRL, sCh->m_uModeRegValue);
}


//////////
// Function Name : POST_SetInFifoMode
// Function Description : Set POST input path to eInPostPath
// Input : 	eInPostPath - Input path
//			sCh - POST structure base address
// Output : 	None
void POST_SetInFifoMode(POST_PATH eInPostPath, POST *sCh)
{
	PostInp32(POST_MODE_CTRL, sCh->m_uModeRegValue);
	
	if (eInPostPath == POST_FIFO)
		sCh->m_uModeRegValue |= (1U<<31);
	else
		sCh->m_uModeRegValue &= ~(1U<<31);

	PostOutp32(POST_MODE_CTRL, sCh->m_uModeRegValue);
}

//////////
// Function Name : POST_IsFreeRunDone
// Function Description : Check if the processing is done
// Input : 	sCh - POST structure base address
// Output : 	true - processing is done
//			false - processing is running
bool POST_IsFreeRunDone(POST *sCh)
{
	u32 uTmp;

	PostInp32(POST_START_VIDEO, uTmp);
	return (((uTmp & (POST_START)) == 0x0) ? true : false);

}


//////////
// Function Name : POST_SetClkSrc
// Function Description : Set the clock for processing
// Input : 	eClkSrc - Video clock source
//			sCh - POST structure base address
// Output : 	None
void POST_SetClkSrc(POST_CLK_SRC eClkSrc, POST *sCh)
{
	u32 uPostPortSelect;
	
	PostInp32(POST_MODE_CTRL, sCh->m_uModeRegValue);

	if(sCh->m_uBaseAddr == POST0_BASE)
		uPostPortSelect = POST_PORT;
	else
		uPostPortSelect = SCALER_PORT;
	
	if((eClkSrc == HCLK))
	{
		if(g_HCLK>66000000)
		{
			sCh->m_uModeRegValue &= ~(0x7F<<23);
			sCh->m_uModeRegValue |= (Post_ClkDivider<<24);		// CLKVAL_F, Clock Source/2
			sCh->m_uModeRegValue |= (1<<23);		// Divided by CLKVAL_F
		}
		else
		{
			sCh->m_uModeRegValue &= ~(0x7F<<23);
		}
		sCh->m_uModeRegValue = (sCh->m_uModeRegValue & ~(0x3<<21)) | (0<<21);
	}
	else if(eClkSrc == PLL_EXT_MOUTEPLL)
	{
		SYSC_SetPLL(eEPLL, 32, 1, 2, 0);		// EPLL => 96MHz
		if(uPostPortSelect == POST_PORT)
			SYSC_ClkSrc(eLCD_MOUTEPLL);
		else
			SYSC_ClkSrc(eSCALER_MOUTEPLL);
		SYSC_ClkSrc(eEPLL_FOUT);

		sCh->m_uModeRegValue &= ~(0x7F<<23);
		sCh->m_uModeRegValue |= (Post_ClkDivider<<24);		// CLKVAL_F, Clock Source/2
		sCh->m_uModeRegValue |= (1<<23);		// Divided by CLKVAL_F	

		sCh->m_uModeRegValue = (sCh->m_uModeRegValue & ~(0x3<<21)) | (1<<21);
	}
	else if(eClkSrc == PLL_EXT_FINEPLL)
	{
		if(uPostPortSelect == POST_PORT)
			SYSC_ClkSrc(eLCD_FINEPLL);
		else
			SYSC_ClkSrc(eSCALER_FINEPLL);
		//SYSC_ClkSrc(eEPLL_FIN);
		sCh->m_uModeRegValue = (sCh->m_uModeRegValue & ~(0x3<<21)) | (1<<21);
	}
	else if(eClkSrc == PLL_EXT_DOUTMPLL)
	{
		if(uPostPortSelect == POST_PORT)
			SYSC_ClkSrc(eLCD_DOUTMPLL);
		else
			SYSC_ClkSrc(eSCALER_DOUTMPLL);
		SYSC_ClkSrc(eMPLL_FOUT);

		sCh->m_uModeRegValue &= ~(0x7F<<23);
		sCh->m_uModeRegValue |= (Post_ClkDivider<<24);		// CLKVAL_F, Clock Source/2
		sCh->m_uModeRegValue |= (1<<23);		// Divided by CLKVAL_F		

		sCh->m_uModeRegValue = (sCh->m_uModeRegValue & ~(0x3<<21)) | (1<<21);
	}
	else		//27MHz Ext Clock Input
	{
		sCh->m_uModeRegValue &= ~(0x7F<<23);
		sCh->m_uModeRegValue = (sCh->m_uModeRegValue & ~(0x3<<21)) | (3<<21);
	}
	
	PostOutp32(POST_MODE_CTRL, sCh->m_uModeRegValue);

	if(uPostPortSelect == POST_PORT)
		ePost_ClkSrc = eClkSrc;
	else
		eScaler_ClkSrc = eClkSrc;
}


//////////
// Function Name : POST_SetClockDivide
// Function Description : Set the clock divider for processing
// Input : 	uDivider - Divide value
//			sCh - POST structure base address
// Output : 	None
void POST_SetClockDivide(u32 uDivider, POST *sCh)
{
	Assert(uDivider >= 1);

	Post_ClkDivider = uDivider&0x3F;
	PostInp32(POST_MODE_CTRL, sCh->m_uModeRegValue);
	sCh->m_uModeRegValue = (sCh->m_uModeRegValue & ~(0x3F<<24)) | (Post_ClkDivider<<24) | (1<<23);   
	PostOutp32(POST_MODE_CTRL, sCh->m_uModeRegValue);
	
}


//////////
// Function Name : POST_GetClockDivide
// Function Description : Set the clock divider for processing
// Input : 	uDivider - Divide value
//			sCh - POST structure base address
// Output : 	None
u32  POST_GetClockDivide(POST *sCh)
{
	return Post_ClkDivider;
}


//////////
// Function Name : POST_CalcurateScaleOffset
// Function Description : Calcurate the Scale Ratio to satisfy the word boundary constraints
// Input : 	uSrcWidth - Source Image Width
//			uSrcHeight - Source Image Height
//			uDstWidth - Source Image Width
//			uDstHeight - Source Image Height
//			sCh - POST structure base address
// Output :	uHOffset - Horizontal Offset Value
//			uVOffset - Vetical Offset Value
//			uHRatio - Horizontal Ratio Value
//			uVRatio - Vetical Ratio Value
void POST_CalcurateScaleOffset(	u32 uSrcWidth, u32 uSrcHeight, u32 uDstWidth, u32 uDstHeight, POST *sCh, 
									u32 *uHOffset, u32 *uVOffset, u32 *uHRatio, u32 *uVRatio, CSPACE eSrcCSpace)
{
	u32 uPreHratio, uPreVratio;
	
	Assert( !(uSrcWidth >= (uDstWidth<<6)) );
	Assert( !(uSrcHeight >= (uDstHeight<<6)) );
	
	if ( uSrcWidth >= (uDstWidth<<5) )
		uPreHratio = 32;
	else if ( uSrcWidth >= (uDstWidth<<4) )
		uPreHratio = 16;
	else if ( uSrcWidth >= (uDstWidth<<3) )
		uPreHratio = 8;
	else if ( uSrcWidth >= (uDstWidth<<2) )
		uPreHratio = 4;
	else if ( uSrcWidth >= (uDstWidth<<1) )
		uPreHratio = 2;
	else
		uPreHratio = 1;

	if ( uSrcHeight >= (uDstHeight<<5) )
		uPreVratio = 32;
	else if ( uSrcHeight >= (uDstHeight<<4) )
		uPreVratio = 16;
	else if ( uSrcHeight >= (uDstHeight<<3) )
		uPreVratio = 8;
	else if ( uSrcHeight >= (uDstHeight<<2) )
		uPreVratio = 4;
	else if ( uSrcHeight >= (uDstHeight<<1) )
		uPreVratio = 2;
	else
		uPreVratio = 1;

	if(eSrcCSpace == YC420)
	{
		*uHOffset = 4*uPreHratio;
		if(*uHOffset < 8)
			*uHOffset = 8;
	}
	else
		*uHOffset = 4*uPreHratio;
	*uVOffset = 2*uPreVratio;
	*uHRatio = uPreHratio;
	*uVRatio = uPreVratio;
}


void POST_SetScalerforTVout(u32 uSrcImgSizeX, u32 uSrcImgSizeY, u32 uSrcFrameAddr, CSPACE eSrcCSpace, 
								u32 uDstImgSizeX, u32 uDstImgSizeY, POST *sCh)
{
	u32 uWidth, uHeight;

	uWidth = uDstImgSizeX;
	uHeight = uDstImgSizeY;
	
	POST_InitCh(POST_B, sCh);

	POST_InitIp1(	uSrcImgSizeX, uSrcImgSizeY, 0, 0, uSrcImgSizeX, uSrcImgSizeY, uSrcFrameAddr, eSrcCSpace,
					uWidth*2, uHeight, 0, 0, uWidth*2, uHeight, 0, YCBYCR,
					1, FALSE, FREE_RUN, POST_DMA, POST_FIFO, sCh);
	POST_SetInterlaceModeOnOff(1, sCh);
	POST_SetNextFrameStAddr(uSrcFrameAddr, 0, sCh);
	POST_StartProcessing(sCh);
}