camif.c

samsung 2410 demo源代码

/************************************************************
File Name	: camif.c
Descriptions
 -S3C24A0 camera test routines & basic libraries
History
 - July 23, 2003. Draft Version 0.0 by purnnamu
 - Janualy 15, 2004. Modifed by Boaz

Copyright (c) 2004 SAMSUNG Electronics.
# However, Anybody can use this code without our permission.  
*************************************************************/

#include <stdio.h>
#include <stdlib.h>

#include "def.h"
#include "2413addr.h"
#include "console.h"
#include "pll.h"

#include "camif.h"
#include "camproset.h"
#include "lcdlib.h"
#include "glib.h"

#define TEST_DETAIL_EN				(FALSE)

//#define	YCbCrtoR(Y,Cb,Cr)	(1000*Y + 1371*(Cr-128))/1000
//#define 	YCbCrtoG(Y,Cb,Cr)	(1000*Y - 336*(Cb-128) - 698*(Cr-128))/1000
//#define	YCbCrtoB(Y,Cb,Cr)	(1000*Y + 1732*(Cb-128))/1000


volatile U32 camTestMode;
volatile U32 camCodecCaptureCount;
volatile U32 camPviewCaptureCount;
volatile U32 camCodecStatus;
volatile U32 camPviewStatus;
volatile U32 amount;
volatile U32 cameraDone;
volatile U32 camCodecDataValid;
volatile U32 camPviewDataValid;

U32 CAMTYPE, CAMSIZE, CAMIICID;
extern U32 CAMTYPE, CAMSIZE, CAMIICID;

volatile U32 regCIPRSCPRERATIO, regCIPRSCPREDST, regCIPRSCCTRL, regCIWDOFST;
U32 camCodecInput, camCodecOutput, camPviewOutput;
U32 cscDone;





//static PPOST_CONFIG _pPostCfgIsr;

//static U32 freeBufStartAddr=NULL; 

void CalculateBurstSize(U32 dstHSize,U32 *mainBurstSize,U32 *RemainedBurstSize);
void __irq CamPviewIsr(void);
void __irq CamCodecIsr(void);


void Test_CamPreviewTestQVGADisplay(void);
void Test_CamCodecPostTestQVGADisplay(void);
void Test_CamCodecPreviewQVGADisplay(void);
void Test_CamCodecQVGADisplay(void);
void Display_Cam_Image(U32 size_x, U32 size_y);
void CamCaptureStart(U32 mode);
void CamCaptureStop(void);
void _CamPviewStopHw(void);
void _CamCodecStopHw(void);
void _CamCodecSetLastIrq(void);
void _CamPviewSetLastIrq(void);
void CamPortInit(void);
void CamClockInit(void);
U32 Conv_YCbCr_Rgb(U8 y0, U8 y1, U8 cb0, U8 cr0);




void * camera_function[][2]=
{
	(void *)Test_CamCodecPreviewQVGADisplay,				"Test_CamCodecPreview 16bpp             ",
	(void *)Camera_WriteBlock,								"IIC Write Block                        ",
	(void *)Camera_ReadBlock,								"IIC Read Block                         ",
	0,0
};

void CameraDisplayFunction(void)
{
	int i;

	i=0;	
	printf("\n\n");
	while(1)	{   //display menu
	    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");
	}
}

void Ch22_CAMERA(void)
{
	int i;

	printf("\n----Test of Camera Interface----\n");

	CamPortInit();
	CamClockInit();

	//LCD Initializtion

	camCodecOutput=CAM_CCIR420;
	camCodecInput=CAM_CCIR420;
	camPviewOutput=CAM_RGB16B;

	printf("Select camera type\n");
	printf("0:S5X532, 1:OV7620 8bit, 2:OV7620 16bit\n");
	printf("Choose one:");
	i=GetIntNum();
	switch(i) {
		case 0:
			CAMTYPE=CAM_S5X532;
			CAMIICID=0x5a;
			break;
		case 1:
			CAMTYPE=CAM_OV7620;
			CAMIICID=0x42;
			break;
		case 2:
			CAMTYPE=CAM_OV7620_16;
			CAMIICID=0x42;
			break;			
		default:
			CAMTYPE=CAM_S5X532;
			CAMIICID=0x5a;
			break;
	}

	printf("Select camera size\n");
	printf("0:VGA,    1:1 Mega,     2:2 Mega\n");
	printf("Choose one:");
	i=GetIntNum();
	switch(i) {
		case 0:
			CAMSIZE=VGA_XSIZE;
			break;
		case 1:
			CAMSIZE=MEGA1_XSIZE;
			break;
		case 2:
			CAMSIZE=MEGA2_XSIZE;
			break;
		default:
			CAMSIZE=VGA_XSIZE;
			break;
	}

	
	rCIGCTRL|=(1<<31);
	Delay(100);
	rCIGCTRL&=~(1<<31);

	printf("Select camera clcok\n");
	printf(" 0:32Mhz,    1:24Mhz,  2:19.2Mhz,  3:16Mhz\n");
	printf(" 4:13.7Mhz, 5:12Mhz,  6:10.6Mhz,  7:9.6Mhz\n");
	printf(" 8:8.7Mhz,   9:8Mhz,  10:7.3Mhz,  11:6.8Mhz\n");
	printf("12:6.4Mhz,  13:6Mhz\n");
	printf("Choose one:");
	i=GetIntNum();
	switch(i) {
		case 0:
			rCLKDIVN=(rCLKDIVN&~(0xf<<16))|(0x2<<16);
			break;
		case 1:
			rCLKDIVN=(rCLKDIVN&~(0xf<<16))|(0x3<<16);
			break;
		case 2:	
			rCLKDIVN=(rCLKDIVN&~(0xf<<16))|(0x4<<16);
			break;
		case 3:
			rCLKDIVN=(rCLKDIVN&~(0xf<<16))|(0x5<<16);
			break;			
		case 4:
			rCLKDIVN=(rCLKDIVN&~(0xf<<16))|(0x6<<16);
			break;			
		case 5:
			rCLKDIVN=(rCLKDIVN&~(0xf<<16))|(0x7<<16);
			break;			
		case 6:
			rCLKDIVN=(rCLKDIVN&~(0xf<<16))|(0x8<<16);
			break;			
		case 7:
			rCLKDIVN=(rCLKDIVN&~(0xf<<16))|(0x9<<16);
			break;
		case 8:
			rCLKDIVN=(rCLKDIVN&~(0xf<<16))|(0xa<<16);
			break;
		case 9:
			rCLKDIVN=(rCLKDIVN&~(0xf<<16))|(0xb<<16);		
			break;
		case 10:
			rCLKDIVN=(rCLKDIVN&~(0xf<<16))|(0xc<<16);
			break;			
		case 11:
			rCLKDIVN=(rCLKDIVN&~(0xf<<16))|(0xd<<16);
			break;
		case 12:
			rCLKDIVN=(rCLKDIVN&~(0xf<<16))|(0xe<<16);
			break;
		case 13:
			rCLKDIVN=(rCLKDIVN&~(0xf<<16))|(0xf<<16);		
			break;
		default:
			break;
	}
	
	CamReset();		
	CameraModuleSetting();
	Delay(10);
			
	while(1) {
		CameraDisplayFunction();
		printf("\nSelect(-1 to exit): ");
		i = GetIntNum();
		//printf("IN:%d.\n\n", i);
		if(i==-1) break;
		
		if(i>=0 && (i<(sizeof(camera_function)/8)) ) 
	    	( (void (*)(void)) (camera_function[i][0]) )();	// execute selected function.
	}

}


/******************************************************************************
 *                                                                            *    
 *                   camera interface interrupts & controls                   *
 *                                                                            *     
 ******************************************************************************/

void __irq CamCodecIsr(void)
{

	U32 completedFrameIndex;

	printf("C");
	ClearPending(BIT_CAM);
	//printf("0x%x, 0x%x\n", rCICOSTATUS&0xe0000000, rCIPRSTATUS&0xc0000000);
	switch(camCodecStatus) {
		case CAM_STOP_ISSUED:
			_CamCodecSetLastIrq();
			camCodecStatus=CAM_LASTIRQ_ISSUED;
			break;
		case CAM_LASTIRQ_ISSUED:
			_CamCodecStopHw();
			camCodecStatus=CAM_LAST_CAPTURING;
			break;			
		case CAM_LAST_CAPTURING:
			camCodecStatus=CAM_STOPPED;
			return;
		case CAM_STARTED:
			if(camTestMode&CAM_TEST_MODE_CODEC_POST)	{
				if(camCodecCaptureCount>0) {
					camCodecDataValid=1;
					//if((postProcessingDone==0) && (camCodecCaptureCount>1)) {
					//	printf("ERROR:Post not completed yet.\n");
					//}
					//completedFrameIndex=(((rCICOSTATUS>>26)&0x3)+4-2)%4;   
					//PostStartProcessing(completedFrameIndex);
				}
			}
			else {
				if(camCodecCaptureCount>0) camCodecDataValid=1;
			}
			break; 
		case CAM_CODEC_SCALER_BYPASS_STATE:
			break;
		default:
			break;
	}

    camCodecCaptureCount++;	 

}
void CamCaptureStart(U32 mode)
{ 
    
	if(mode&CAM_CODEC_SCALER_CAPTURE_ENABLE_BIT) {
		camCodecStatus=CAM_STARTED;
		rCICOSCCTRL|=CAM_CODEC_SACLER_START_BIT;
	}
	
    
	rCIIMGCPT|=CAM_CAMIF_GLOBAL_CAPTURE_ENABLE_BIT|mode;
}

void CamCaptureStop(void)
{
	camCodecStatus=CAM_STOP_ISSUED;
	camPviewStatus=CAM_STOP_ISSUED;
}


void _CamCodecSetLastIrq(void)
{
	rCICOCTRL|=(1<<2); // Bit of LastIRQEn_Co is cleared automatically.  
}

void _CamCodecStopHw(void)
{
	rCICOSCCTRL&=~CAM_CODEC_SACLER_START_BIT; //stop codec scaler.
	rCIIMGCPT&=~(CAM_CAMIF_GLOBAL_CAPTURE_ENABLE_BIT|CAM_CODEC_SCALER_CAPTURE_ENABLE_BIT); //stop capturing for codec scaler and global capture.
}


/******************************************************************************
 *                                                                            *    
 *                       camera interface initialization                      *
 *                                                                            *     
 ******************************************************************************/

void CamReset()
{

	//rCLKDIVN=(rCLKDIVN&~(0xf<<8))|(0x1<<8);

	switch(CAMTYPE) {
		case CAM_OV7620:
		case CAM_OV7620_16:
			rCIGCTRL|= (1<<31)|(1<<29); //camera I/F soft reset
			Delay(1);
			rCIGCTRL&= ~(1<<31);

			rCIGCTRL|=(1<<30);	//external camera reset assertion (OV7620=high active)	
			Delay(200);
			rCIGCTRL&=~(1<<30);		//external camera reset deassertion

			rCIGCTRL|=(1<<26);  // XciPCLK Polarity setting