cameratest.c

三星公司S3c2443的测试程序源码

#include <stdio.h>
#include <string.h>

#include "2443addr.h"

#include "Console.h"
#include "Display.h"

#include "Camera.h"
#include "CameraData.h"

typedef struct {
	int	ITU601_656;
	int Order422;
	int Hsize;
	int Vsize;
	int PCLKpolarity;
	int VSYNCpolarity;
	int HREFpolarity;
	char PageRegister;
	void *CamData;
	int	Size;
} CAMERAMODULE;

CAMERAMODULE CameraModule[]=
{
	{ CAMERA_ITU601, ORDER_YCBYCR,  640,  480, InvPolPCLK_INVERSE, InvPolVSYNC_NORMAL, InvPolHREF_NORMAL, 0xec, S5K3AA_YCbCr8bit_VGA, sizeof(S5K3AA_YCbCr8bit_VGA)/2},
	{ CAMERA_ITU656, ORDER_CBYCRY, 1280, 1024, InvPolPCLK_INVERSE, InvPolVSYNC_NORMAL, InvPolHREF_NORMAL, 0xec, S5K3AA_YCbCr8bit_SXGA_656, sizeof(S5K3AA_YCbCr8bit_SXGA_656)/2},
	{ CAMERA_ITU601, ORDER_YCRYCB,  176,  144, InvPolPCLK_NORMAL, InvPolVSYNC_INVERSE, InvPolHREF_NORMAL, 0xfc, S5K3BAFB_YCbCr8bit_QCIF, sizeof(S5K3BAFB_YCbCr8bit_QCIF)/2},
	{ CAMERA_ITU601, ORDER_YCRYCB,  320,  240, InvPolPCLK_NORMAL, InvPolVSYNC_INVERSE, InvPolHREF_NORMAL, 0xfc, S5K3BAFB_YCbCr8bit_QVGA, sizeof(S5K3BAFB_YCbCr8bit_QVGA)/2},
	{ CAMERA_ITU601, ORDER_YCRYCB,  640,  480, InvPolPCLK_NORMAL, InvPolVSYNC_INVERSE, InvPolHREF_NORMAL, 0xfc, S5K3BAFB_YCbCr8bit_VGA, sizeof(S5K3BAFB_YCbCr8bit_VGA)/2},
	{ CAMERA_ITU601, ORDER_YCRYCB, 1280, 1024, InvPolPCLK_NORMAL, InvPolVSYNC_INVERSE, InvPolHREF_NORMAL, 0xfc, S5K3BAFB_YCbCr8bit_SXGA, sizeof(S5K3BAFB_YCbCr8bit_SXGA)/2},
	{ CAMERA_ITU601, ORDER_YCRYCB, 1600, 1200, InvPolPCLK_NORMAL, InvPolVSYNC_INVERSE, InvPolHREF_NORMAL, 0xfc, S5K3BAFB_YCbCr8bit_UXGA, sizeof(S5K3BAFB_YCbCr8bit_UXGA)/2}
};


#define	CameraPreviewFrameBuffer	(_NONCACHE_STARTADDRESS+0x01000000)
#define	CameraCodecFrameBuffer		(_NONCACHE_STARTADDRESS+0x01800000)

#define CAPTURE_STOPPED				(0)
#define CAPTURING					(1)
#define CAPTURE_STOP_ISSUED			(2)
#define CAPTURE_LASTIRQ_ISSUED		(3)
#define CAPTURE_LAST_IRQ			(4)


#define CAMIICID		(0x5a)

static int CAMTYPE;

static volatile unsigned int camCodecCaptureCount, camCodecStatus, camCodecDataValid;
static volatile unsigned int camPviewCaptureCount, camPviewStatus, camPviewDataValid;
static volatile unsigned int PreviewComplete;

static int TESTPATTERN, FLIPMODE;

void InitCameraModule( void)
{
	printf("Select camera type\n");
	printf("0: S5K3AA (VGA)      1: S3K3AA (SXGA-ITU656)    2: S5K3BAFB (QCIF)     3: S5K3BAFB (QVGA)\n");
	printf("4: S5K3BAFB (VGA)    5: S5K3BAFB (SXGA)         6: S5K3BAFB (UXGA)\n");
	printf("Choose one [D=0]:");

	CAMTYPE = GetIntNum();

	if ((CAMTYPE<0)||(CAMTYPE>=sizeof(CameraModule)/40))
		CAMTYPE = 0;

	OpenCameraIIC(400000);
	SetupCameraModule( CAMIICID, CameraModule[CAMTYPE].CamData, CameraModule[CAMTYPE].Size );
	CloseCameraIIC();

	ResetCameraInterface();
	SetCameraSourceFormat(CameraModule[CAMTYPE].ITU601_656,UVOFFSET_0,CameraModule[CAMTYPE].Order422);
	SetCameraSourceSize(CameraModule[CAMTYPE].Hsize,CameraModule[CAMTYPE].Vsize);
	SetCameraInterfacePolarity(CameraModule[CAMTYPE].PCLKpolarity,CameraModule[CAMTYPE].VSYNCpolarity,CameraModule[CAMTYPE].HREFpolarity);
	SetCameraWindowOffset(WINDOWOFFSET_DISABLE,0,0,0,0);

	printf("\n\nCamera Module Initialize complete.\n");
}

void ReadCameraModuleStatus( void)
{
	unsigned int i;
	char Data;
	char *A;

	OpenCameraIIC(400000);

	A =	CameraModule[CAMTYPE].CamData;

	for(i=0; i<CameraModule[CAMTYPE].Size;i++) {
		if(A[i*2+0] == CameraModule[CAMTYPE].PageRegister) {
			WriteCameraModule( CAMIICID, CameraModule[CAMTYPE].PageRegister, A[i*2+1]);
			printf("Page: 0x%02x\n",  A[i*2+1]);
		} else {
			ReadCameraModule( CAMIICID, A[i*2+0], &Data);
			printf("Addr: 0x%02x, W: 0x%02x, R: 0x%02x\n", A[i*2+0], A[i*2+1], Data);
		}
	}

	CloseCameraIIC();
}


void CameraIF_PreviewISR();
void CameraIF_CodecISR();

void __irq CameraISR( void)
{
	if (rSUBSRCPND & BIT_SUB_CAM_P) {
		rSUBSRCPND = BIT_SUB_CAM_P;
		printf("p");
		CameraIF_PreviewISR();
	}
	
	if (rSUBSRCPND & BIT_SUB_CAM_C) {
		rSUBSRCPND = BIT_SUB_CAM_C;
		printf("c");
		CameraIF_CodecISR();
	}
	
	ClearPending(BIT_CAM);
}

void __irq MSDMAISR( void)
{
	if (rSUBSRCPND & BIT_SUB_CAM_P) {
		rSUBSRCPND = BIT_SUB_CAM_P;
		printf("m");
		PreviewComplete = 1;
	}

	if (rSUBSRCPND & BIT_SUB_CAM_C) {
		rSUBSRCPND = BIT_SUB_CAM_C;
		printf("c");
		CameraIF_CodecISR();
	}
	
	ClearPending(BIT_CAM);
}



//************************************************************************
//*		Codec test
//************************************************************************

void CodecCaptureStart( void)
{ 
	camCodecCaptureCount	=	0;
	camCodecStatus			=	CAPTURING;

	EnableCodecDMA();
	EnableCodecScaler();
	EnableImageCaptureCodec();
	EnableImageCapture();
}

void CodecCaptureStop(void)
{
	camCodecStatus	=	CAPTURE_STOP_ISSUED;
}

void CameraIF_CodecISR(void)
{
	switch(camCodecStatus) {

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

	case CAPTURING	:
			break;

	case CAPTURE_STOP_ISSUED	:
			EnableCodecLastIRQ();
			camCodecStatus	=	CAPTURE_LASTIRQ_ISSUED;
			break;

	case CAPTURE_LASTIRQ_ISSUED	:
			DisableImageCapture();
			DisableImageCaptureCodec();
			DisableCodecScaler();
			DisableCodecDMA();
			camCodecStatus	=	CAPTURE_LAST_IRQ;
			break;			

	case CAPTURE_LAST_IRQ	:
			camCodecStatus	=	CAPTURE_STOPPED;
			break;
	}

	if (camCodecCaptureCount>0)
		camCodecDataValid	=	1;

	camCodecCaptureCount++;	
}


void CameraCodec( void)
{
	unsigned int OutFormat;
	int i, fb;

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

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

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

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

	SetCodecFormat( InFormat_YCBCR422, OutFormat, INTERLEAVE_ON, ORDER_YCBYCR);
	SetCodecScaler( CameraModule[CAMTYPE].Hsize, CameraModule[CAMTYPE].Vsize, lcd_horizon_value, lcd_line_value);
	SetCodecDMA( lcd_horizon_value, lcd_line_value, OutFormat, INTERLEAVE_ON);
	SetCodecFrameBuffer( CameraCodecFrameBuffer, lcd_horizon_value, lcd_line_value, OutFormat, INTERLEAVE_ON);

	SetCodecFlipMode(FLIPMODE);
	SetCameraTestPattern(TESTPATTERN);

	CodecCaptureStart();

	while (1) {
		if (camCodecDataValid) {
			camCodecDataValid = 0;
			i = (GetCodecFrameCount()-2)&0x3;
			fb = GetCodecFrameBuffer(i);

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

	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_C;
}



//************************************************************************
//*		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;
	int i, fb;
	int key;
	
	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;
	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                ",
	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]) )();
	}
}