camera.c

三星 s3c6400测试代码

			+ uSrcOrgHsz/2*uSrcCropStartY/nVRatio + uSrcCropStartX/2;
		uSrcStartCr0 = oCim.m_uSrcAddr0 + uSrcOrgHsz*uSrcOrgVsz + uSrcOrgHsz/2*uSrcOrgVsz/nVRatio
			+ uSrcOrgHsz/2*uSrcCropStartY/nVRatio + uSrcCropStartX/2;
		uSrcEndCb0 = uSrcStartCb0 + uSrcCropHsz/2*uSrcCropVsz/nVRatio + uSrcOffsetCbCr*(uSrcCropVsz/nVRatio-1);
		uSrcEndCr0 = uSrcStartCr0 + uSrcCropHsz/2*uSrcCropVsz/nVRatio + uSrcOffsetCbCr*(uSrcCropVsz/nVRatio-1);

		uSrcStartCb1 = oCim.m_uSrcAddr1+ uSrcOrgHsz*uSrcOrgVsz
			+ uSrcOrgHsz/2*uSrcCropStartY/nVRatio + uSrcCropStartX/2;
		uSrcStartCr1 = oCim.m_uSrcAddr1 + uSrcOrgHsz*uSrcOrgVsz + uSrcOrgHsz/2*uSrcOrgVsz/nVRatio
			+ uSrcOrgHsz/2*uSrcCropStartY/nVRatio + uSrcCropStartX/2;
		Assert(uSrcStartCb0%4 == 0); //Start addr must be word aligned
		Assert(uSrcStartCb1%4 == 0); //Start addr must be word aligned
		Assert(uSrcStartCr0%4 == 0); //Start addr must be word aligned
		Assert(uSrcStartCr1%4 == 0); //Start addr must be word aligned
	} 
	else
	{
		uSrcOffsetCbCr = 0;
		uSrcStartCb0 = 0;
		uSrcEndCb0 = 0;
		uSrcStartCr0 = 0;
		uSrcEndCr0 = 0;
		uSrcStartCb1 = 0;
		uSrcStartCr1 = 0;
	}

	// 4. Set the register of source start address and image size
	//===========================================
	uMSSz = (uSrcCropVsz<<16)|(uSrcCropHsz);
	if (oCim.m_eProcessPath==P_PATH)
	{
		Outp32(&CAMERAR->rMSPRWIDTH, uMSSz); // Set MSDMA source image size

		Outp32(&CAMERAR->rCIPRYSA1, 0);
		Outp32(&CAMERAR->rCIPRYSA2, 0); 
		Outp32(&CAMERAR->rCIPRYSA3, 0);
		Outp32(&CAMERAR->rCIPRYSA4, 0); 
		Outp32(&CAMERAR->rMSPRY0SA, uSrcStartY0); // Set SrcAddr0 Y, Cb, Cr
		Outp32(&CAMERAR->rMSPRY0END, uSrcEndY0);
		Outp32(&CAMERAR->rMSPRCB0SA, uSrcStartCb0);
		Outp32(&CAMERAR->rMSPRCB0END, uSrcEndCb0); 
		Outp32(&CAMERAR->rMSPRCR0SA, uSrcStartCr0);
		Outp32(&CAMERAR->rMSPRCR0END, uSrcEndCr0);
		Outp32(&CAMERAR->rMSPRYOFF, uSrcOffsetY); // Set Offset of Y, Cb, Cr 
		Outp32(&CAMERAR->rMSPRCBOFF, uSrcOffsetCbCr);
		Outp32(&CAMERAR->rMSPRCROFF, uSrcOffsetCbCr);
	}
	else 
	{
		Outp32(&CAMERAR->rMSCOWIDTH, uMSSz);// Set MSDMA source image size

		Outp32(&CAMERAR->rCICOYSA1, 0);
		Outp32(&CAMERAR->rCICOYSA2, 0); 
		Outp32(&CAMERAR->rCICOYSA3, 0);
		Outp32(&CAMERAR->rCICOYSA4, 0); 
		Outp32(&CAMERAR->rMSCOY0SA, uSrcStartY0); // Set SrcAddr0 Y, Cb, Cr
		Outp32(&CAMERAR->rMSCOY0END, uSrcEndY0);
		Outp32(&CAMERAR->rMSCOCB0SA, uSrcStartCb0);
		Outp32(&CAMERAR->rMSCOCB0END, uSrcEndCb0); 
		Outp32(&CAMERAR->rMSCOCR0SA, uSrcStartCr0);
		Outp32(&CAMERAR->rMSCOCR0END, uSrcEndCr0); 
		Outp32(&CAMERAR->rMSCOYOFF, uSrcOffsetY); // Set Offset of Y, Cb, Cr
		Outp32(&CAMERAR->rMSCOCBOFF, uSrcOffsetCbCr);
		Outp32(&CAMERAR->rMSCOCROFF, uSrcOffsetCbCr);
	}
}



//////////
// Function Name : CAMERA_StartPreviewPath
// Function Description : this function : start preview path . 
// Input : 	None
// Output :    	None
void CAMERA_StartPreviewPath(void)
{ 
	u32 uCptEnRegVal;

	// 1. Set p_path main-scaler control register
	//===========================================
	if (oCim.m_bIsScalerBypass!= true)
	{
		oCim.m_uMainScalerCtrl |= (1<<15); // Enable main scaler
		Outp32(&CAMERAR->rCIPRSCCTRL, oCim.m_uMainScalerCtrl);
	}

	// 2. Set image capture register
	//============================================
	uCptEnRegVal = 0; // Image Capture Enable Reg.
	uCptEnRegVal |=(1U<<31)|(1U<<29); // Enable global capture and preview scaler
	uCptEnRegVal &=~(1U<<30);
	uCptEnRegVal &= ~(0x3<<25);
	if (oCim.m_bIsScalerBypass==true) // If bypass-scaler is set,
		uCptEnRegVal &= ~(1<<29); // ImgCptEn_PrSc must be clear
	uCptEnRegVal &= ~(0xffff<<10); // Cclear uCptEnRegVal[25:10]
	Outp32(&CAMERAR->rCIIMGCPT, uCptEnRegVal); 

}


//////////
// Function Name : CAMERA_StartCodecPath
// Function Description : Starts Codec path . 
// Input : 	u32 uCptCnt(Capture count)
// Output :    	None
void CAMERA_StartCodecPath(u32 uCptCnt)
{

	u32 uCptPtr;
	u32 uCptEnRegVal = 0; // Image Capture Enable Reg.

	
	Assert(uCptCnt < 256); //Number of frame counts must be less than 256
	
	// 1. Set c_path main-scaler control register
	//==================================
	if (oCim.m_bIsScalerBypass!= true)
	{
		oCim.m_uMainScalerCtrl |= (1<<15); // Enable main scaler
		Outp32(&CAMERAR->rCICOSCCTRL, oCim.m_uMainScalerCtrl); 
	}

	// 2. Set image capture register
	//==================================
	if (uCptCnt>0)
	{
		Outp32(&CAMERAR->rCICPTSEQ, 0xffffffff); // Apply capture sequence 
		uCptPtr = 0;
		uCptEnRegVal |= (1<<25)|(uCptPtr<<19)|(1<<18)|(uCptCnt<<10) ; // Enable global capture and preview scaler 
	}
	uCptEnRegVal |=(1U<<31); // Enable global capture 
	uCptEnRegVal &= ~(1U<<29); // Disable preview scaler
	if (oCim.m_bIsScalerBypass==true) // if bypass-scaler is set,
		uCptEnRegVal &= ~(1U<<30); // ImgCptEn_CoSc must be clear
	else
		uCptEnRegVal |=(1U<<30); // Enable codec scaler
	Outp32(&CAMERAR->rCIIMGCPT, uCptEnRegVal);

}

//////////
// Function Name : CAMERA_StartDmaInPath
// Function Description : DMA in path start
// Input : 	None
// Output :    	None
void CAMERA_StartDmaInPath(void)
{
	u32 uCptEnRegVal = 0; // Image Capture Enable Reg.
	int nSrcRGBOrder;

	// 1. compute the rgb/YCbYCr order of the source data
	//====================================
	nSrcRGBOrder = (oCim.m_eMemSrcFmt ==RGB16) ? 0 :
		(oCim.m_eMemSrcFmt ==RGB18) ? 1 :
		(oCim.m_eMemSrcFmt ==RGB24) ? 2 : 3;

	// 2. Set the corresponding register(main-scaler control register, MSDMA control register and, image caputre register )
	//=============================================================================
	oCim.m_uMainScalerCtrl &=~(0x3<<13); // Clear the bits
	oCim.m_uMainScalerCtrl |= (nSrcRGBOrder<<13);
		
	if (oCim.m_eOutputPath==DMA)
		CAMERA_ClearFrameEndStatus();
	
	if (oCim.m_eProcessPath==P_PATH)
	{
		Outp32(&CAMERAR->rCIPRSCCTRL, oCim.m_uMainScalerCtrl);

		uCptEnRegVal &= ~(1U<<31|1U<<30); // Disable global capture and codec scaler
		uCptEnRegVal |=(1U<<29); // Enable preview scaler

		if (oCim.m_bIsScalerBypass!= true)
		{
			oCim.m_uMainScalerCtrl |= (1<<15); // Enable main scaler
			Outp32(&CAMERAR->rCIPRSCCTRL, oCim.m_uMainScalerCtrl);
		}
		else 
			uCptEnRegVal &= ~(1<<29); // ImgCptEn_PrSc must be clear

		Outp32(&CAMERAR->rCIIMGCPT, uCptEnRegVal); 
		Outp32(&CAMERAR->rCIMSCTRL, oCim.m_uMSDMACtrl|(1<<0));
	}
	else //if (oCim.m_eProcessPath==C_PATH)
	{
		Outp32(&CAMERAR->rCICOSCCTRL, oCim.m_uMainScalerCtrl);

		uCptEnRegVal &= ~(1U<<31|1U<<29); // Disable global capture and preview scaler
		uCptEnRegVal |=(1U<<30); // Enable codec scaler

		if (oCim.m_bIsScalerBypass!= true)
		{
			oCim.m_uMainScalerCtrl |= (1<<15); // Enable main scaler
			Outp32(&CAMERAR->rCICOSCCTRL, oCim.m_uMainScalerCtrl); 
		}
		else
			uCptEnRegVal &= ~(1<<30); // ImgCptEn_PrSc must be clear

		Outp32(&CAMERAR->rCIIMGCPT, uCptEnRegVal); 
		Outp32(&CAMERAR->rMSCOCTRL, oCim.m_uMSDMACtrl|(1<<0));
	}
}



//////////
// Function Name : CAMERA_StartMSDmaPreviewPath
// Function Description : Camera Input Sorce MSDMA Start(Preview)
// Input : 	None
// Output :    	None
void CAMERA_StartMSDmaPreviewPath(void)
{
	Outp32(&CAMERAR->rCIMSCTRL, oCim.m_uMSDMACtrl|(1<<0));
}


//////////
// Function Name : CAMERA_StartMSDmaCodecPath
// Function Description : Camera Input Sorce MSDMA Start(Preview)
// Input : 	None
// Output :    	None
void CAMERA_StartMSDmaCodecPath(void)
{
	Outp32(&CAMERAR->rMSCOCTRL, oCim.m_uMSDMACtrl|(1<<0));
}

//////////
// Function Name : CAMERA_IsProcessingDone
// Function Description : 
// Input : 	None
// Output :    	None
bool CAMERA_IsProcessingDone(void)
{
	u32 uSfr;
	u32 uResult;
	
	if (oCim.m_eProcessPath==P_PATH)
	{
		uSfr = Inp32(&CAMERAR->rCIPRSTATUS);
		uResult = (uSfr>>19)&0x1;
		return (bool)uResult;
	}
	else
	{
		uSfr = Inp32(&CAMERAR->rCICOSTATUS);
		return( ((uSfr>>17)&0x01) ? true : false ); 
	}
}


//////////
// Function Name : CAMERA_ClearFrameEndStatus
// Function Description : 
// Input : 	None
// Output :    	None
void CAMERA_ClearFrameEndStatus(void)
{
	if (oCim.m_eProcessPath==P_PATH)
		Outp32(&CAMERAR->rCIPRSTATUS, 0);
	else
		Outp32(&CAMERAR->rCICOSTATUS, 0);
}

//////////
// Function Name : CAMERA_StopPreviewPath
// Function Description : Stop Preview path operation
// Input : 	None
// Output :    	None
void CAMERA_StopPreviewPath(void)
{
	oCim.m_uMainScalerCtrl &= ~(1<<15); // Disable main scaler
	// jungil0214
	oCim.m_uMainScalerCtrl &= ~(1<<31); // Disable bypass 

	Outp32(&CAMERAR->rCIPRSCCTRL, oCim.m_uMainScalerCtrl);
	Outp32(&CAMERAR->rCIIMGCPT, 0);
}

//////////
// Function Name : CAMERA_StopCodecPath
// Function Description : Stop Codec path operation
// Input : 	None
// Output :    	None
void CAMERA_StopCodecPath(void)
{
	oCim.m_uMainScalerCtrl &= ~(1<<15); // Disable main scaler
	// jungil0214
	oCim.m_uMainScalerCtrl &= ~(1<<31); // Disable bypass 
	Outp32(&CAMERAR->rCICOSCCTRL, oCim.m_uMainScalerCtrl);
	Outp32(&CAMERAR->rCIIMGCPT, 0);
	
}

//////////
// Function Name : CAMERA_StopDmainPath
// Function Description : stop dma in path operation
// Input : 	None
// Output :    	None
void CAMERA_StopDmaInPath(void)
{
//	u32 uImgCptRegVal;
//	u32 uMSDMACtrl;
//	u32 uSfr;

	oCim.m_uMainScalerCtrl &= ~(1<<15); // Disable main scaler

	if (oCim.m_eProcessPath==P_PATH)
	{
		Outp32(&CAMERAR->rCIPRSCCTRL, oCim.m_uMainScalerCtrl);
		Outp32(&CAMERAR->rCIIMGCPT, 0);
	}
	else //oCim.m_eProcessPath==C_PATH
	{
		Outp32(&CAMERAR->rCICOSCCTRL, oCim.m_uMainScalerCtrl);
		Outp32(&CAMERAR->rCIIMGCPT, 0);
	}
}



//////////
// Function Name : CAMERA_SetDstScanOffset
// Function Description : Scan Line Offset setting function 
// Input : 	
//		u32 uDisplayHSz(Wanted display H size), u32 uDisplayVSz(Wanted display V size), 
//		u32 uDisplayStartX(Display start X), u32 uDisplayStartY(Display start Y), u32 uDstAddr0(Destination address 0 ), u32 uDstAddr1(Destination address 1)
// Output :    	None
void CAMERA_SetDstScanOffset(u32 uDisplayHSz, u32 uDisplayVSz, 
	u32 uDisplayStartX, u32 uDisplayStartY, u32 uDstAddr0, u32 uDstAddr1)
{ 
	u32 uOutYSz, uBytePerPixrl;
	u32 uInitYOffset;
	u32 uLineYOffset;
	u32 uScanYOff;
	u32 uInitCrOffset, uLineCrOffset, uInitCbOffset, uLineCbOffset, uScanCrOff ,uScanCbOff ;


	
	// 1. Compute oCim.m_uDstHsz, uOutYSz and uBytePerPixrl
	//===================================================
	oCim.m_uDstHsz = (oCim.m_eOutRotDeg==ROT_90) ? oCim.m_uDstVsz: oCim.m_uDstHsz;

	uOutYSz = uDisplayHSz*uDisplayVSz;
	uBytePerPixrl = (oCim.m_eDstFmt == RGB18||oCim.m_eDstFmt == RGB24)? 4:
		 (oCim.m_eDstFmt == YC422||oCim.m_eDstFmt == YC420) ? 1 : 2;

	// 2. Move the start point form (0,0) to (0, uDisplayStartY), then compute the start address again.
	//=============================================================
	if (oCim.m_eProcessPath==P_PATH&&oCim.m_eOutputPath==DMA)
	{
		Outp32(&CAMERAR->rCIPRYSA1, uDstAddr0 + uDisplayHSz*uDisplayStartY*uBytePerPixrl);
		Outp32(&CAMERAR->rCIPRYSA2, uDstAddr1 + uDisplayHSz*uDisplayStartY*uBytePerPixrl);
		Outp32(&CAMERAR->rCIPRYSA3, uDstAddr0 + uDisplayHSz*uDisplayStartY*uBytePerPixrl);
		Outp32(&CAMERAR->rCIPRYSA4, uDstAddr1 + uDisplayHSz*uDisplayStartY*uBytePerPixrl);
		
		if (oCim.m_eDstFmt==YC422)
		{
			Outp32(&CAMERAR->rCIPRCBSA1, uDstAddr0 + uOutYSz + uDisplayHSz*uDisplayStartY/2);
			Outp32(&CAMERAR->rCIPRCRSA1, uDstAddr0 + uOutYSz + uOutYSz/2 + uDisplayHSz*uDisplayStartY/2);
			Outp32(&CAMERAR->rCIPRCBSA2, uDstAddr1 + uOutYSz + uDisplayHSz*uDisplayStartY/2);
			Outp32(&CAMERAR->rCIPRCRSA2, uDstAddr1 + uOutYSz + uOutYSz/2 + uDisplayHSz*uDisplayStartY/2);
			Outp32(&CAMERAR->rCIPRCBSA3, uDstAddr0 + uOutYSz + uDisplayHSz*uDisplayStartY/2);
			Outp32(&CAMERAR->rCIPRCRSA3, uDstAddr0 + uOutYSz + uOutYSz/2 + uDisplayHSz*uDisplayStartY/2);
			Outp32(&CAMERAR->rCIPRC