cameratest.c

三星2443芯片

{
	rCICOYSA1	=	(0x31000000+0x01800000);
	rCICOYSA2	=	rCICOYSA1+(320*240*2);
	rCICOYSA3	=	rCICOYSA2+(320*240*2);
	rCICOYSA4	=	rCICOYSA3+(320*240*2);
}
void SetCodecDstOffset(U32 uDisplayHSz, U32 uStartX, U32 uStartY)
{

/*
	U32 InitOffset = uDisplayHSz*uStartY + uStartX;
	U32 LineOffset = uDisplayHSz - 160;

	if (InitOffset >= 0x1000)
	{
		printf("\nInitial Offset error\n");
		return;
	}

	printf("\nInitial Offset = %x\n",InitOffset);
*/
	rCICOSCOS = (160<<16) | (160<<0);
	printf("\nrCICOSCOS = %x\n",rCICOSCOS);

}

void SetCodec_ScanLine_Bubffer(U32 FrameNumber)
{

	switch(FrameNumber)
		{
		case 0:
			//Frame 0
			rCICOYSA1	=	CameraCodecFrameBuffer;
			rCICOYSA2	=	rCICOYSA1+(lcd_horizon_value*lcd_line_value*2);
			rCICOYSA3	=	rCICOYSA2+(lcd_horizon_value*lcd_line_value*2);
			rCICOYSA4	=	rCICOYSA3+(lcd_horizon_value*lcd_line_value*2);
			rCICOSCOS   =     (0<<16) | ((lcd_horizon_value -160) <<0);
			break;
			
		case 1:
			//Frame 1
			rCICOYSA1	=	CameraCodecFrameBuffer;
			rCICOYSA2	=	rCICOYSA1+(lcd_horizon_value*lcd_line_value*2);
			rCICOYSA3	=	rCICOYSA2+(lcd_horizon_value*lcd_line_value*2);
			rCICOYSA4	=	rCICOYSA3+(lcd_horizon_value*lcd_line_value*2);
			rCICOSCOS   =     (160<<16) | ((lcd_horizon_value -160) <<0);
			break;

		case 2:			
			//Frame 2
			rCICOYSA1	=	CameraCodecFrameBuffer + 320*120*2;
			rCICOYSA2	=	rCICOYSA1+(lcd_horizon_value*lcd_line_value*2);
			rCICOYSA3	=	rCICOYSA2+(lcd_horizon_value*lcd_line_value*2);
			rCICOYSA4	=	rCICOYSA3+(lcd_horizon_value*lcd_line_value*2);
			rCICOSCOS   =     (0<<16) | ((lcd_horizon_value -160) <<0);
			break;

		case 3:
			//Frame 3		
			rCICOYSA1	=	CameraCodecFrameBuffer +  320*120*2;
			rCICOYSA2	=	rCICOYSA1+(lcd_horizon_value*lcd_line_value*2);
			rCICOYSA3	=	rCICOYSA2+(lcd_horizon_value*lcd_line_value*2);
			rCICOYSA4	=	rCICOYSA3+(lcd_horizon_value*lcd_line_value*2);	
			rCICOSCOS   =     (160<<16) | ((lcd_horizon_value -160) <<0);
			break;
		}
}

//************************************************************************
//*		Preview test
//************************************************************************

void StartPreviewCapture( void)
{ 
	camPviewCaptureCount	=	0;
	camPviewStatus			=	CAPTURING;

	EnablePreviewScaler();
	EnableImageCapturePreview();
	EnableImageCapture();
}

void PreviewCaptureStop(void)
{
	camPviewStatus	=	CAPTURE_STOP_ISSUED;
}

void CameraIF_PreviewISR(void)
{
	switch(camPviewStatus) {

	case CAPTURE_STOPPED	:					//	It will never happen.
			break;
			
	case CAPTURING	:
			break;

	case CAPTURE_STOP_ISSUED	:
			EnablePreviewLastIRQ();
			camPviewStatus	=	CAPTURE_LASTIRQ_ISSUED;
			break;

	case CAPTURE_LASTIRQ_ISSUED	:
			DisableImageCapture();
			DisableImageCapturePreview();
			DisablePreviewScaler();
			camPviewStatus	=	CAPTURE_LAST_IRQ;
			break;			

	case CAPTURE_LAST_IRQ	:
			camPviewStatus	=	CAPTURE_STOPPED;
			break;
	}

	if (camPviewCaptureCount>0)
		camPviewDataValid	=	1;
				
	camPviewCaptureCount++;	
}


void CameraPreview( void)
{
	unsigned int OutFormat=0;
	int i, fb;
	
	
	switch(lcd_bpp)
	{
	case WINCONx_16BPP_565 : 
		OutFormat = OutFormat_RGB16B;
		break;
	case WINCONx_24BPP_888 : 
		OutFormat = OutFormat_RGB24B;
		break;
	}

	printf("Camera Preview path test.\n");

	camPviewStatus=CAPTURE_STOPPED;
	camPviewCaptureCount=0;
	camPviewDataValid=0;

	pISR_CAM	=	(unsigned int)CameraISR;
	rSUBSRCPND = BIT_SUB_CAM_P|BIT_SUB_CAM_C;
	ClearPending(BIT_CAM);
	rINTSUBMSK &= ~BIT_SUB_CAM_P;
	rINTMSK &= ~BIT_CAM;

	SetPreviewPath(CameraModule[CAMTYPE].Hsize, CameraModule[CAMTYPE].Vsize, lcd_horizon_value, lcd_line_value, OutFormat);
	SetPreviewFrameBuffer(CameraPreviewFrameBuffer, lcd_horizon_value, lcd_line_value, OutFormat);

	SetPreviewFlipMode(FLIPMODE);
	SetCameraTestPattern(TESTPATTERN);

	SetPreviewSource(PREVIEW_CAMERA);

	StartPreviewCapture();

	while (1) {
		if (camPviewDataValid) {
			camPviewDataValid = 0;
			i = (GetPreviewFrameCount()-2)&0x3;
			fb = GetPreviewFrameBuffer(i);

			*VIDWxADD0_Reg_Addr[0][0] = fb;
		}
		if (Uart_GetKey()== '\r') break;
	}

	PreviewCaptureStop();

	while(!(camPviewStatus==CAPTURE_STOPPED ));

	printf("\ncamPviewCaptureCount=%d\n",camPviewCaptureCount);
	printf("preview Status register:0x%x\n", rCIPRSTATUS);

	rINTMSK |= BIT_CAM;
	rINTSUBMSK |= BIT_SUB_CAM_P;
}


//************************************************************************
//*		MSDMA test
//************************************************************************

void MSDMAPreview( void)
{
	unsigned int OutFormat=0;
	unsigned int i,fb;

	switch(lcd_bpp)
	{
	case WINCONx_16BPP_565 : 
		OutFormat = OutFormat_RGB16B;
		break;
	case WINCONx_24BPP_888 : 
		OutFormat = OutFormat_RGB24B;
		break;
	}

	printf("MSDMA test. (Get YCBCR data from camera with codec path. And put the image into MSDMA.)\n");

	camCodecStatus=CAPTURE_STOPPED;
	camCodecCaptureCount=0;
	camCodecDataValid=0;

	pISR_CAM	=	(unsigned int)MSDMAISR;
	rSUBSRCPND = BIT_SUB_CAM_P|BIT_SUB_CAM_C;
	ClearPending(BIT_CAM);
	rINTSUBMSK &= ~(BIT_SUB_CAM_P|BIT_SUB_CAM_C);
	rINTMSK &= ~BIT_CAM;


	SetCodecFormat( InFormat_YCBCR422, OutFormat_YCBCR422, INTERLEAVE_ON, ORDER_CRYCBY);
	SetCodecScaler( CameraModule[CAMTYPE].Hsize, CameraModule[CAMTYPE].Vsize, CameraModule[CAMTYPE].Hsize, CameraModule[CAMTYPE].Vsize);
	SetCodecDMA( CameraModule[CAMTYPE].Hsize, CameraModule[CAMTYPE].Vsize, OutFormat_YCBCR422, INTERLEAVE_ON);
	SetCodecFrameBuffer( CameraCodecFrameBuffer, CameraModule[CAMTYPE].Hsize, CameraModule[CAMTYPE].Vsize, OutFormat_YCBCR422, INTERLEAVE_ON);

	//	Use MSDMA Offset
	SetPreviewPath( CameraModule[CAMTYPE].Hsize, CameraModule[CAMTYPE].Vsize, lcd_horizon_value, lcd_line_value, OutFormat);
	SetPreviewFrameBuffer( CameraPreviewFrameBuffer, lcd_horizon_value, lcd_line_value, OutFormat);
	SetPreviewSource( PREVIEW_MSDMA);

	SetMSDMAFormat( MSDMA_InFormat_YCBCR422, INTERLEAVE_ON, ORDER_CRYCBY);

	CodecCaptureStart();

	EnablePreviewScaler();
	EnableImageCapturePreview();

	while (1) {
		if (camCodecDataValid) {
			camCodecDataValid = 0;

			i = GetCodecFrameCount();
			fb = GetCodecFrameBuffer((i-2)&0x3);

			SetMSDMAFrameBuffer( fb, CameraModule[CAMTYPE].Hsize, CameraModule[CAMTYPE].Vsize, 0, MSDMA_InFormat_YCBCR422);

			PreviewComplete=0;

			StartMSDMA();
			WaitMSDMA();

			while(PreviewComplete==0);

			i = GetPreviewFrameCount();
			fb = GetPreviewFrameBuffer((i-1)&0x3);

			*VIDWxADD0_Reg_Addr[0][0] = fb;

		}
		if (Uart_GetKey()== '\r') break;			
	}

	DisableImageCapturePreview();
	DisablePreviewScaler();

	CodecCaptureStop();

	while(!(camCodecStatus==CAPTURE_STOPPED ));

	printf("\ncamCodecCaptureCount=%d\n",camCodecCaptureCount);
	printf("codec Status register:0x%x\n", rCICOSTATUS);

	rINTMSK |= BIT_CAM;
	rINTSUBMSK |= BIT_SUB_CAM_P|BIT_SUB_CAM_C;
}

void TestPattern( void)
{
	printf("Select Test Pattern : 0) No pattern (Camera)    1) Color Bar    2) Horizontal Increment    3) Vertical Increment\n");
	
	TESTPATTERN = GetIntNum();

	if ((TESTPATTERN<0)||(TESTPATTERN>3))
		TESTPATTERN = 0;
}

void FlipTest( void)
{
	printf("Select Flip mode : 0) Nomal    1) X-axis mirror    2) y-axis mirror    3) 180 deg rotation\n");

	FLIPMODE = GetIntNum();

	if ((FLIPMODE<0)||(FLIPMODE>3))
		FLIPMODE = 0;
}


void CamGpio_Init(void)
{
	rGPJCON = 0x2aaaaaa;				//	Camif enable [25:0]
	rGPJUDP = 0x2aaaaaa;				//	Camif port pull-up disable [12:0]
}

void CamClk_Set(void)
{
    int i;
    
	//	Camera IF Clock divider setup
	printf("EPLLOUT: 96MHz\n");
	printf("Select camera clock divider\n");
	printf("Choose one [Input Clock/n, n=1~16, D=4]:");

	rLOCKCON1=rLOCKCON1 & ~(0xffff)|(0x800);
	rEPLLCON=(0<<24)|(0x28<<16)|(0x1<<8)|(0x1); //96MHz

	rCLKSRC|=(1<<6);  // EPLL Output
		
    i=GetIntNum();
	if ((i<1)||(i>16)) i=4;
	
    rCLKDIV1 = (rCLKDIV1 & ~(0xf<<26))|((i-1)<<26);	

}

void * camera_function[][2]=
{
	(void *)InitCameraModule,			"Initialize Camera Module    ",
	(void *)ReadCameraModuleStatus,		"Read Camera Module Status   ",
	(void *)CameraCodec,					"Codec mode Test             ",
	(void *)CameraPreview,				"Preview mode Test           ",
	(void *)MSDMAPreview,				"MSDMA test with Codec mode  ",
	(void *)TestPattern,					"TEST Pattern setting        ",
	(void *)FlipTest,						"FLIP setting                ",
	(void *)CameraCodec_ScanLine_Offset, "Codec Scan Line Offset Test    ",
	0,0
};

void Test_Camera(void)
{
	int i;

	CamGpio_Init();

    	CamClk_Set();

	Setup_RgbIf();

	while(1) {
		i=0;	
		printf("\n\n");
		while(1) {
		    printf("%2d:%s",i,camera_function[i][1]);
		    i++;
		    if((int)(camera_function[i][0])==0) {
				printf("\n");
				break;
		    }
		    if((i%2)==0) printf("\n");
		}

		printf("\nSelect(-1 to exit): ");
		i = GetIntNum();
		printf("\n");

		if(i==-1) break;
		if(i>=0 && (i<(sizeof(camera_function)/8)-1) ) 
	    	( (void (*)(void)) (camera_function[i][0]) )();
	}
}