camera.c

三星2443芯片

			rCICOYSA4	=	rCICOYSA3+TargetHsize*TargetVsize*2;

			rCICOCBSA1	=	rCICOYSA1+TargetHsize*TargetVsize;
			rCICOCBSA2	=	rCICOYSA2+TargetHsize*TargetVsize;
			rCICOCBSA3	=	rCICOYSA3+TargetHsize*TargetVsize;
			rCICOCBSA4	=	rCICOYSA4+TargetHsize*TargetVsize;

			rCICOCRSA1	=	rCICOCBSA1+(TargetHsize*TargetVsize/2);
			rCICOCRSA2	=	rCICOCBSA2+(TargetHsize*TargetVsize/2);
			rCICOCRSA3	=	rCICOCBSA3+(TargetHsize*TargetVsize/2);
			rCICOCRSA4	=	rCICOCBSA4+(TargetHsize*TargetVsize/2);
		}
	} else {
		BytesPerPixel = GetCodecBytesPerPixel(OutFormat,Interleave);

		rCICOYSA1	=	FrameBuffer;
		rCICOYSA2	=	rCICOYSA1+(TargetHsize*TargetVsize*BytesPerPixel);
		rCICOYSA3	=	rCICOYSA2+(TargetHsize*TargetVsize*BytesPerPixel);
		rCICOYSA4	=	rCICOYSA3+(TargetHsize*TargetVsize*BytesPerPixel);
	}
}

void SetCodecScalerBypass( void)
{
	rCICOSCCTRL	|=	(1u<<31);
}

void EnableCodecScaler( void)
{
	rCICOSCCTRL |= (1<<15);
}

void DisableCodecScaler( void)
{
	rCICOSCCTRL &= ~(1<<15);
}

void SetCodecScaler( unsigned int SRC_Height, unsigned int SRC_Width, unsigned int DST_Height, unsigned int DST_Width)
{
	unsigned int PreHorRatio,PreVerRatio;
	unsigned int MainHorRatio, MainVerRatio;
	unsigned int H_Shift, V_Shift;

	CalculatePrescalerRatioShift( SRC_Height, DST_Height, &PreHorRatio, &H_Shift);
	CalculatePrescalerRatioShift( SRC_Width, DST_Width, &PreVerRatio, &V_Shift);

	MainHorRatio	=	(SRC_Height<<8)/(DST_Height<<H_Shift);
	MainVerRatio	=	(SRC_Width<<8)/(DST_Width<<V_Shift);

	//	Codec Pre-scaler control
	rCICOSCPRERATIO	=	((10-(H_Shift+V_Shift))<<28)|(PreHorRatio<<16)|(PreVerRatio);
	rCICOSCPREDST	=	((SRC_Height/PreHorRatio)<<16)|(SRC_Width/PreVerRatio);

	//	Codec Main-scaler control
	rCICOSCCTRL		&=	~((1<<31)|(0x1ff<<16)|(0x1ff));
	rCICOSCCTRL		|=	(0<<31)|(MainHorRatio<<16)|(MainVerRatio);

	if (SRC_Height<=DST_Height)	rCICOSCCTRL	|=	(1<<30);
	if (SRC_Width<=DST_Width)	rCICOSCCTRL	|=	(1<<29);
}

void SetCodecDMA( unsigned int TargetHsize, unsigned int TargetVsize, unsigned int OutFormat, unsigned int Interleave)
{
	unsigned int MainBurstLengthY = 0 , RemainedBurstLengthY = 0;
	unsigned int MainBurstLengthC = 0 , RemainedBurstLengthC = 0;
	unsigned int BytesPerPixel;

	BytesPerPixel = GetCodecBytesPerPixel( OutFormat, Interleave);

	CalculateBurstSize( TargetHsize*BytesPerPixel, &MainBurstLengthY, &RemainedBurstLengthY);
	
	MainBurstLengthC = MainBurstLengthY/2;
	RemainedBurstLengthC = RemainedBurstLengthY/2;

	if (Interleave==1)
	{
		MainBurstLengthY /= 2;
		RemainedBurstLengthY /= 2;
		MainBurstLengthC /= 2;
		RemainedBurstLengthC /= 2;
	}

	//	Codec DMA control
	rCICOCTRL	=	(rCICOCTRL & ~((0x1f<<19)|(0x1f<<14)|(0x1f<<9)|(0x1f<<4))) 
					| (MainBurstLengthY<<19)|(RemainedBurstLengthY<<14)|(MainBurstLengthC<<9)|(RemainedBurstLengthC<<4);

	//	Codec DMA target area.
	rCICOTAREA	=	TargetHsize*TargetVsize;
	
	rCICOTRGFMT	=	(rCICOTRGFMT & ~((0x1fff<<16)|(0x1fff<<0))) | (TargetHsize<<16)|(TargetVsize<<0);

}

void EnableCodecLastIRQ( void)
{
	rCICOCTRL |= (1<<2);
}

void SetCodecFlipMode( unsigned int FlipMd)
{
	rCICOTRGFMT	= (rCICOTRGFMT	& ~(0x3<<14)) | (FlipMd<<14);
}

unsigned int GetCodecFrameCount( void)
{
	return ((rCICOSTATUS>>26)&0x3);	
}

unsigned int GetCodecFrameBuffer( unsigned int FrameNumber)
{
	unsigned int FrameBuffer = 0;
	
	switch (FrameNumber) {
	case 0	:	FrameBuffer = rCICOYSA1;
				break;
	case 1	:	FrameBuffer = rCICOYSA2;
				break;
	case 2	: 	FrameBuffer = rCICOYSA3;
				break;
	case 3	:	FrameBuffer = rCICOYSA4;
				break;
	}

	return (FrameBuffer);
}

//*******************************************************************
//*		Functions for Camera Preview Path
//*******************************************************************

void EnableImageCapturePreview( void)
{
	rCIIMGCPT |= (1<<29);
}

void DisableImageCapturePreview( void)
{
	rCIIMGCPT &= ~(1<<29);
}

static unsigned int GetPreviewBytesPerPixel( unsigned int OutFormat)
{
	unsigned int BytesPerPixel=0;
	
	switch(OutFormat)
	{
	case OutFormat_RGB16B :
		BytesPerPixel = 2;
		break;

	case OutFormat_RGB24B :
		BytesPerPixel = 4;
		break;
	}

	return BytesPerPixel;
}

void SetPreviewSource( unsigned int SEL_DMA_CAM)
{
	rCIMSCTRL = (rCIMSCTRL & ~(1<<2)) | (SEL_DMA_CAM<<2);
}

void SetPreviewFrameBuffer( unsigned int FrameBuffer, unsigned int TargetHsize, unsigned int TargetVsize, unsigned int OutFormat)
{
	unsigned int BytesPerPixel;

	BytesPerPixel = GetPreviewBytesPerPixel(OutFormat);

	//	PingPong Frame Buffer
	rCIPRCLRSA1	=	FrameBuffer;
	rCIPRCLRSA2	=	rCIPRCLRSA1+TargetHsize*TargetVsize*BytesPerPixel;
	rCIPRCLRSA3	=	rCIPRCLRSA2+TargetHsize*TargetVsize*BytesPerPixel;
	rCIPRCLRSA4	=	rCIPRCLRSA3+TargetHsize*TargetVsize*BytesPerPixel;
}

void EnablePreviewScaler( void)
{
	rCIPRSCCTRL |= (1<<15);
}

void DisablePreviewScaler( void)
{
	rCIPRSCCTRL &= ~(1<<15);
}

void SetPreviewPath( unsigned int SRC_Height, unsigned int SRC_Width, unsigned int TargetHsize, unsigned int TargetVsize, unsigned int OutFormat)
{
	unsigned int PreHorRatio, PreVerRatio;
	unsigned int MainHorRatio, MainVerRatio;
	unsigned int H_Shift, V_Shift;
	unsigned int MainBurstLength = 0, RemainedBurstLength = 0;
	unsigned int BytesPerPixel;


	rCIPRSCCTRL = (rCIPRSCCTRL & ~(1<<30)) | (OutFormat<<30);


	CalculatePrescalerRatioShift( SRC_Height, TargetHsize, &PreHorRatio, &H_Shift);
	CalculatePrescalerRatioShift( SRC_Width, TargetVsize, &PreVerRatio, &V_Shift);
	
	MainHorRatio	=	(SRC_Height<<8)/(TargetHsize<<H_Shift);
	MainVerRatio	=	(SRC_Width<<8)/(TargetVsize<<V_Shift);
	
	//	Preview Pre-scaler control
	rCIPRSCPRERATIO	=	((10-H_Shift-V_Shift)<<28)|(PreHorRatio<<16)|(PreVerRatio);		 
	rCIPRSCPREDST	=	((SRC_Height/PreHorRatio)<<16)|(SRC_Width/PreVerRatio);

	//	Preview Main-scaler control
	rCIPRSCCTRL		&=	~((1<<29)|(1<<28)|(0x1ff<<16)|(0x1ff));
	rCIPRSCCTRL		|=	(MainHorRatio<<16)|(MainVerRatio);

	if (SRC_Height<=TargetHsize)	rCIPRSCCTRL	|=	(1<<29);
	if (SRC_Width<=TargetVsize)		rCIPRSCCTRL	|=	(1<<28);


	BytesPerPixel = GetPreviewBytesPerPixel(OutFormat);

	CalculateBurstSize( TargetHsize * BytesPerPixel, &MainBurstLength, &RemainedBurstLength);

	//	Preview DMA control
   	rCIPRCTRL	=	(rCIPRCTRL	& ~((0x1f<<19)|(0x1f<<14))) | (MainBurstLength<<19)|(RemainedBurstLength<<14);

	//	Preview DMA target area.
	rCIPRTAREA	=	TargetHsize*TargetVsize;
	
	rCIPRTRGFMT	=	(rCIPRTRGFMT & ~((0x1fff<<16)|(0x1fff<<0))) | (TargetHsize<<16)|(TargetVsize<<0);
}

void EnablePreviewLastIRQ( void)
{
	rCIPRCTRL	|=	(1<<2);
}

void SetPreviewCSCRange( unsigned int CSCRange)
{
	rCIPRTRGFMT	=	(rCIPRTRGFMT & ~(0x3<<30)) | (CSCRange<<30);
}

void SetPreviewFlipMode( unsigned int FlipMode)
{
	rCIPRTRGFMT	=	(rCIPRTRGFMT & ~(0x3<<14)) | (FlipMode<<14);
}

unsigned int GetPreviewFrameCount( void)
{
	return (rCIPRSTATUS>>26)&0x3;
}

unsigned int GetPreviewFrameBuffer( unsigned int FrameNumber)
{
	unsigned int FrameBuffer = 0;
	
	switch (FrameNumber) {
	case 0	:	FrameBuffer = rCIPRCLRSA1;
				break;
	case 1	:	FrameBuffer = rCIPRCLRSA2;
				break;
	case 2	: 	FrameBuffer = rCIPRCLRSA3;
				break;
	case 3	:	FrameBuffer = rCIPRCLRSA4;
				break;
	}

	return FrameBuffer;
}

//*******************************************************************
//*		Functions for MSDMA
//*******************************************************************

void SetMSDMAFormat( unsigned int InFormat, unsigned int Interleave, unsigned int Order422)
{
	rCIMSCTRL	=	(rCIMSCTRL & ~((0x1<<5)|(0x3<<3)|(0x1<<1))) | (Interleave<<5)|(Order422<<3)|(InFormat<<1);
}

void SetMSDMAFrameBuffer( unsigned int FrameBuffer, unsigned int SRC_Width, unsigned int SRC_Height, unsigned int SRC_Offset, unsigned int InFormat)
{
	switch(InFormat)
	{
	case MSDMA_InFormat_YCBCR422 :
		rCIMSYSA	=	FrameBuffer+SRC_Offset*2;
		rCIMSYEND	=	rCIMSYSA+(SRC_Width*SRC_Height)*2+SRC_Offset*2*(SRC_Height-1);
		rCIMSYOFF	=	SRC_Offset*2;
		break;

	case MSDMA_InFormat_YCBCR420 :
		rCIMSYSA	=	FrameBuffer+SRC_Offset;
		rCIMSYEND	=	rCIMSYSA+(SRC_Width*SRC_Height)+SRC_Offset*(SRC_Height-1);
		rCIMSYOFF	=	SRC_Offset;

		rCIMSCBSA	=	rCIMSYEND+SRC_Offset;
		rCIMSCBEND	=	rCIMSCBSA+(SRC_Width/2*SRC_Height/2)+SRC_Offset*(SRC_Height/2-1);
		rCIMSCBOFF	=	SRC_Offset;

		rCIMSCRSA	=	rCIMSCBEND+SRC_Offset;
		rCIMSCREND	=	rCIMSCRSA+(SRC_Width/2*SRC_Height/2)+SRC_Offset*(SRC_Height/2-1);
		rCIMSCROFF	=	SRC_Offset;
		break;
	}

	rCIMSWIDTH	=	SRC_Width;
}

void StartMSDMA( void)
{
	//	clear ENVID_MS
	rCIMSCTRL &= ~(1<<0);
	//	Set ENVID_MS
	rCIMSCTRL |= (1<<0);
}

void WaitMSDMA( void)
{
	//	Waiting for EOF_MS
	while (rCIMSCTRL&(1<<6)==0);
}