cameratest.c

samsung 最新芯片2450 的测试程序.

#include "system.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(20000);
	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(100000);

	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 __irq CameraISR( void)
{
	rINTSUBMSK |=BIT_SUB_CAM_C;
	rINTMSK |= BIT_CAM;
	
	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);

	rINTSUBMSK &=~BIT_SUB_CAM_C;
	rINTMSK &=~ 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();
	}
	printf("i");
	ClearPending(BIT_CAM);
}



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

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

	EnableCodecDMA();
	EnableCodecScaler();

#if 0  // bypass mode
	SetCodecScalerBypass();
	rCIIMGCPT &=~ (3<<30);  // scacler bypass
#else if // Scaler mode
	EnableImageCaptureCodec();
#endif
	EnableImageCapture();
/*	
   //capture count test
	rCICOCPTSEQ=0x1000ffff;
	rCIIMGCPT=rCIIMGCPT& ~ (0x3fff<<10)|(0xf<<10)|(0x0<<18)|(0xf<<19);
*/
}

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 = 0;
	int i, fb;

	InitCameraModule();

	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;

  //     SetCameraWindowOffset(WINDOWOFFSET_ENABLE,400,360,400,360); // jcs for offset test
       
	SetCodecFormat( InFormat_YCBCR422, OutFormat, INTERLEAVE_ON, ORDER_YCBYCR);
	SetCodecScaler( CameraModule[CAMTYPE].Hsize, CameraModule[CAMTYPE].Vsize, lcd_horizon_value, lcd_line_value); // org
		
       // for max input
//	SetCodecScaler( CameraModule[CAMTYPE].Hsize, CameraModule[CAMTYPE].Vsize,1600, 1200);

	// jcs for offset test
// 	SetCodecScaler( lcd_horizon_value, lcd_line_value, lcd_horizon_value, lcd_line_value); 

       SetCodecDMA( lcd_horizon_value, lcd_line_value, OutFormat, INTERLEAVE_ON); // org
	

	
	// for max input
//	SetCodecDMA( 1600, 1200, OutFormat, INTERLEAVE_ON);


	SetCodecFrameBuffer( CameraCodecFrameBuffer, lcd_horizon_value, lcd_line_value, OutFormat, INTERLEAVE_ON);
	// for max input
//	SetCodecFrameBuffer( CameraCodecFrameBuffer, 1600, 1200, OutFormat, INTERLEAVE_ON);


// FLIP mode & Pattern test

	printf("\nFLIP MODE: 00: Normal, 01:X-axis, 02: Y-axis, 03: 180 degree ");
  	FLIPMODE= GetIntNum();
  
	printf("\n");
	SetCodecFlipMode(FLIPMODE);
	
	printf("\nTEST PATTERN: 00: Normal, 01:color bar, 02: horizontal, 03: vertical ");
 	TESTPATTERN= GetIntNum();
  	
	printf("\n");
	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, %x\n",camCodecCaptureCount, rCIIMGCPT);
	printf("codec Status register:0x%x\n", rCICOSTATUS);

	rINTMSK |= BIT_CAM;
	rINTSUBMSK |= BIT_SUB_CAM_C;
}

void CameraCodec_ScanLine_Offset( void)
{

#if 1

	unsigned int OutFormat = 0;
	int i, fb;
	unsigned int *Codecframebuffer, *Previewframebuffer;

	Previewframebuffer = (U32 *)CameraCodecFrameBuffer;
	
	InitCameraModule();

	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;

	for(i=0; i<480*800*2*4; i++) {
		*Previewframebuffer ++ = 0x0;
	}	
       
	SetCodecFormat( InFormat_YCBCR422, OutFormat, INTERLEAVE_ON, ORDER_YCBYCR);

	SetCodecScaler( CameraModule[CAMTYPE].Hsize, CameraModule[CAMTYPE].Vsize, 320, 240);
	
	SetCodecDMA( 320, 240, OutFormat, INTERLEAVE_ON);

	SetCodecFrameBuffer( CameraCodecFrameBuffer, lcd_horizon_value, lcd_line_value, OutFormat, INTERLEAVE_ON);

	rCICOSCOS   =  rCICOSCOS&~(0xffffffff)|(480<<16) |((480) <<0); //initial offset, line offset
     
	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, %x\n",camCodecCaptureCount, rCIIMGCPT);
	printf("codec Status register:0x%x\n", rCICOSTATUS);

	rINTMSK |= BIT_CAM;
	rINTSUBMSK |= BIT_SUB_CAM_C;


	#else if
	
	unsigned int OutFormat = 0;
	unsigned int i,fb;

	unsigned int *Codecframebuffer, *Previewframebuffer;
	unsigned int TargetHsize, TargetVsize;//, StartPixelNumber;

	InitCameraModule();

	printf("CPU I/F Display Controller Test!\n");

	TargetHsize = 320;  //jcs
	TargetVsize =240;


	Codecframebuffer = (U32 *)CameraCodecFrameBuffer;
	Previewframebuffer = (U32 *)CameraPreviewFrameBuffer;


	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");