s3c6400_camera.cpp

Samsung公司S3C6400芯片的BSP源码包

#include <windows.h>
#include <types.h>
#include <string.h>
#include <stdio.h>
#include <tchar.h>
#include <nkintr.h>
//#include <oalintr.h>
#include <pm.h>
#include "pmplatform.h"
#include <ceddk.h>
#include <S3c6400.h>
#include <bsp.h>
#include <pmplatform.h>
#include <DrvLib.h>
#include "s3c6400_camera.h"
#include "Module.h"

// For Debug
#define CAM_MSG				0
#define CAM_INOUT			0
#define	CAM_ERR				1
// Macros

// Definitions
//#define CAM_CLK_DIV			6
#define	CAM_CLK_SOURCE			(S3C6400_HCLKx2)


#define CAM_CODEC_SACLER_START_BIT			(1<<15)
#define CAM_PVIEW_SACLER_START_BIT			(1<<15)

#define CAM_CAMIF_GLOBAL_CAPTURE_ENABLE_BIT		(1<<31)
#define CAM_CODEC_SCALER_CAPTURE_ENABLE_BIT		(1<<30)
#define CAM_PVIEW_SCALER_CAPTURE_ENABLE_BIT		(1<<29)

#define CAM_OFFSET_STEP						(4)

// structures
typedef struct {
	UINT32	Width;
	UINT32	Height;
	int		Format;
	int 	Size;
	int		FrameSize;
} BUFFER_DESC;

// Variables

// Pointer to camera driver instance which we will send back with callback functions
DWORD dwCameraDriverContext;

// Signals the application that the video or still image frame is available
PFNCAMHANDLEFRAME pfnCameraHandleVideoFrame = NULL;
PFNCAMHANDLEFRAME pfnCameraHandleStillFrame = NULL;
PFNCAMHANDLEFRAME pfnCameraHandlePreviewFrame = NULL;

volatile S3C6400_GPIO_REG *s6400IOP = NULL;
volatile S3C6400_CAMIF_REG    *s6400CAM = NULL;
//volatile S3C6400_INTR_REG	*s6400INT = NULL;
volatile S3C6400_SYSCON_REG *s6400PWR = NULL;

BUFFER_DESC	Video_Buffer;
BUFFER_DESC	Still_Buffer;
BUFFER_DESC	Preview_Buffer;

PHYSICAL_ADDRESS PhysPreviewAddr;
PHYSICAL_ADDRESS PhysCodecAddr;

PBYTE	pPreviewVirtAddr;
PBYTE	pCodecVirtAddr;

BYTE	PreviewOn=0;
BYTE	CodecOn=0;
BYTE	VideoOn=0;
BYTE	StillOn=0;

UINT32	PreviewFrameCnt=0;			// this is for skipping first 3 frames. Because first 3 frames are useless.
UINT32	CodecFrameCnt=0;			// this is for skipping first 3 frames. Because first 3 frames are useless.

INT32	gHorOffset1=0;
INT32	gVerOffset1=0;
INT32	gHorOffset2=0;
INT32	gVerOffset2=0;


UINT32	g_CamIrq_C = IRQ_CAMIF_C;
UINT32	g_CamSysIntr_C = SYSINTR_UNDEFINED;
UINT32	g_CamIrq_P = IRQ_CAMIF_P;
UINT32	g_CamSysIntr_P = SYSINTR_UNDEFINED;

HANDLE	CaptureThread;
HANDLE	CaptureEvent;
HANDLE	PreviewThread;
HANDLE	PreviewEvent;

HANDLE hPwrControl;

// Functions
void CameraGpioInit();		//	Initialize GPIO setting for Camera Interface
void CameraInterfaceReset();	// Reset Camera Inteface IP
void CameraModuleReset();		// Reset Camera Module
void CameraSetClockDiv();	// Clock Div setting
void CameraCaptureSourceSet();		// Set source registers

void CameraSetCodecRegister(UINT32 width, UINT32 height, int Format);		// set codec register
void CameraSetPreviewRegister(UINT32 width, UINT32 height, int Format); 	// set preview register

void CameraSetScaler(UINT32 width, UINT32 height, int path);

void CalculateBurstSize(unsigned int hSize,unsigned int *mainBurstSize,unsigned int *remainedBurstSize);
void CalculatePrescalerRatioShift(unsigned int SrcSize, unsigned int DstSize, unsigned int *ratio,unsigned int *shift);

UINT32 CalculateBufferSize(UINT32 width, UINT32 height, int format);

BOOL InitializeBuffer();
BOOL DeinitializeBuffer();

BOOL InterruptInitialize();

DWORD WINAPI CameraCaptureThread(void);
DWORD WINAPI CameraPreviewThread(void);

static void Delay(UINT32 count)
{
	volatile int i, j = 0;
	volatile static int loop = S3C6400_FCLK/100000;

	for(;count > 0;count--)
		for(i=0;i < loop; i++) { j++; }
}

int CameraInit(void *pData)
{
	RETAILMSG(CAM_INOUT,(TEXT("++++++++++++++++++CameraInit\n")));
	// 0. Map to Virtual Address

	// GPIO Virtual alloc
	s6400IOP = (S3C6400_GPIO_REG *)DrvLib_MapIoSpace(S3C6400_BASE_REG_PA_GPIO, sizeof(S3C6400_GPIO_REG), FALSE);
	if (s6400IOP == NULL)
	{
		RETAILMSG(1,(TEXT("For s6400IOP: DrvLib_MapIoSpace failed!\r\n")));
		return FALSE;;
	}

	// Camera Virtual alloc
	s6400CAM = (S3C6400_CAMIF_REG *)DrvLib_MapIoSpace(S3C6400_BASE_REG_PA_CAMIF, sizeof(S3C6400_CAMIF_REG), FALSE);
	if (s6400CAM == NULL)
	{
		RETAILMSG(1,(TEXT("For s6400CAM: DrvLib_MapIoSpace failed!\r\n")));
		return FALSE;;
	}

	// PWM clock Virtual alloc
	s6400PWR = (S3C6400_SYSCON_REG *)DrvLib_MapIoSpace(S3C6400_BASE_REG_PA_SYSCON, sizeof(S3C6400_SYSCON_REG), FALSE);
	if (s6400PWR == NULL)
	{
		RETAILMSG(1,(TEXT("For s6400PWR: DrvLib_MapIoSpace failed!\r\n")));
		return FALSE;;
	}

	hPwrControl = CreateFile( L"PWC0:", GENERIC_READ|GENERIC_WRITE, FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, 0);
	if (INVALID_HANDLE_VALUE == hPwrControl )
	{
		RETAILMSG(CAM_ERR, (TEXT("[CAM] CameraInit() : PWC0 Open Device Failed\r\n")));
		return FALSE;
	}

	ModuleInit();

	CameraSetClockDiv();

    // 1. Camera IO setup
	CameraGpioInit();	
	
    // 2. Camera Clock setup
    CameraClockOn(TRUE);

	// 3. camera module reset
	CameraModuleReset();	
	/*
	// 4. Write Setting for Module using I2C
	if(!ModuleWriteBlock())
	{
		return FALSE;
	}	
    
	// 5. Camera i/f reset
    CameraInterfaceReset();

    // 6. Initialize I/F source register
    CameraCaptureSourceSet();
    */
    // 7. Camera Clock Off
    CameraClockOn(FALSE);  
	    
	// 8. Allocation Buffer();
	if(!InitializeBuffer())
	{
		return FALSE;
	}

	// 9. Interrupt Initlaize();
	if(!InterruptInitialize())
	{
		return FALSE;
	}

    RETAILMSG(CAM_INOUT,(TEXT("------------------CameraInit\n")));

    return TRUE;
}

void CameraDeinit()
{
	RETAILMSG(CAM_INOUT,(TEXT("++++++++++++++++++CameraDeInit\n")));

	if(s6400IOP != NULL)
	{
		DrvLib_UnmapIoSpace((PVOID)s6400IOP);
		s6400IOP = NULL;
	}
	if(s6400CAM != NULL)
	{
		DrvLib_UnmapIoSpace((PVOID)s6400CAM);
		s6400CAM = NULL;
	}
	if(s6400PWR != NULL)
	{
		DrvLib_UnmapIoSpace((PVOID)s6400PWR);
		s6400PWR = NULL;
	}

	ModuleDeinit();
	DeinitializeBuffer();

	CloseHandle(CaptureThread);
	CloseHandle(CaptureEvent);
	CloseHandle(PreviewThread);
	CloseHandle(PreviewEvent);
	RETAILMSG(CAM_INOUT,(TEXT("------------------CameraDeInit\n")));
}

void CameraGpioInit()		//	Initialize GPIO setting for Camera Interface
{
	s6400IOP->GPFPUD = (s6400IOP->GPFPUD & ~(0x3ffffff)); 		// CAM IO PullUpDown Disable setup except CAMRESET
	s6400IOP->GPFCON = (s6400IOP->GPFCON & ~(0x3ffffff)) | 0x2aaaaaa;
}

void CameraInterfaceReset()	// Reset Camera Inteface IP
{
	// This functin is used on power handler operation.
	// So, you should not use Kernel API functions as like as "Sleep()".

	MODULE_DESCRIPTOR value;

	ModuleGetFormat(value);
	//
	// Camera (FIMC2.0) I/F Reset
	//
	s6400CAM->CISRCFMT |= (1<<31);		// 6400 board manual recommend   added by jjg 06.07.19
	s6400CAM->CIGCTRL |= (1<<31);
	s6400CAM->CIGCTRL &= ~(1<<31);

	if(value.ITUXXX == CAM_ITU656)
	{
		s6400CAM->CISRCFMT &= ~(1<<31);
	}
}

void CameraModuleReset()		// Reset Camera Module
{
	MODULE_DESCRIPTOR value;

	ModuleGetFormat(value);

	if(value.HighRst)
	{
		s6400CAM->CIGCTRL |= (1<<30);
		// Don't modify this delay time
		Delay(100);
		s6400CAM->CIGCTRL &= ~(1<<30);
		// Wait for Camera module initialization
		Delay(1000);
	}
	else
	{
		//s6400CAM->CIGCTRL |= (1<<30);
		// Wait for Camera module initialization
		//Delay(1000);
		s6400CAM->CIGCTRL &= ~(1<<30);
		// Wait for Camera module initialization
		Delay(100);

		s6400CAM->CIGCTRL |= (1<<30);
		// Don't modify this delay time
		Delay(1000);
	}
}

void CameraClockOn(BOOL bOnOff)
{
	DWORD dwIPIndex = PWR_IP_CAMIF;
	DWORD dwBytes;	
	static int isOn = 0;
	RETAILMSG(CAM_INOUT,(TEXT("++++++++++++++++++[CAM] CameraClockOn %d\n"),bOnOff));
	// Camera clock
	if (!bOnOff)
	{
		if(isOn == 1)
		{
			isOn = 0;
			s6400PWR->HCLK_GATE &= ~(1<<10); // Camera clock disable
			s6400PWR->SCLK_GATE &= ~(1<<2); // Camera clock disable		
			if ( !DeviceIoControl(hPwrControl, IOCTL_PWRCON_SET_POWER_OFF, &dwIPIndex, sizeof(DWORD), NULL, 0, &dwBytes, NULL) )
			{
				RETAILMSG(CAM_ERR,(TEXT("[CAM:ERR] CameraClockOn(%d) : IOCTL_PWRCON_SET_POWER_OFF Failed\r\n")));
			}			
		}
	}
	else 
	{
		if(isOn == 0)
		{
			isOn = 1;
			
			if ( !DeviceIoControl(hPwrControl, IOCTL_PWRCON_SET_POWER_ON, &dwIPIndex, sizeof(DWORD), NULL, 0, &dwBytes, NULL) )
			{
				RETAILMSG(CAM_ERR,(TEXT("[CAM:ERR] CameraClockOn(%d) : IOCTL_PWRCON_SET_POWER_OFF Failed\r\n")));
			}		
				
			s6400PWR->HCLK_GATE |= (1<<10); // Camera clock enable
			s6400PWR->SCLK_GATE |= (1<<2); // Camera clock enable		
			Delay(1000);
		}
	}
	RETAILMSG(CAM_INOUT,(TEXT("------------------[CAM] CameraClockOn\n")));
}

void CameraCaptureSourceSet()		// Set source registers
{
	UINT32 WinOfsEn=0;
	RETAILMSG(CAM_INOUT,(TEXT("++++++++++++++++++CameraCaptureSourceSet\n")));
	MODULE_DESCRIPTOR value;

	ModuleGetFormat(value);

	s6400CAM->CIGCTRL = ((value.HighRst ? 0 : 1)<<30)|(1<<29)|(0<<27)|(value.InvPCLK<<26)|
						(value.InvVSYNC<<25)|(value.InvHREF<<24)|(0<<22)|(1<<21)|(1<<20); // inverse PCLK
	s6400CAM->CIWDOFST = (1<<30)|(0xf<<27)|(0xf<<12); // clear overflow
	s6400CAM->CIWDOFST = 0;

	if((value.SourceHOffset > 0) || (value.SourceVOffset > 0))
	{
		WinOfsEn=1;
	}
	s6400CAM->CIWDOFST = (WinOfsEn<<31)|(value.SourceHOffset <<16)|(value.SourceVOffset);
	s6400CAM->CIDOWSFT2 = (value.SourceHOffset <<16)|(value.SourceVOffset);

	//TODO:: Set Offset for scaler
	s6400CAM->CISRCFMT = (value.ITUXXX<<31)|(value.UVOffset<<30)|(0<<29)|
							(value.SourceHSize<<16)|(value.Order422<<14)|(value.SourceVSize);

	RETAILMSG(CAM_MSG,(TEXT("s6400CAM->CISRCFMT=0x%08X\n"),s6400CAM->CISRCFMT));
	RETAILMSG(CAM_INOUT,(TEXT("------------------CameraCaptureSourceSet\n")));
}

int CameraPrepareBuffer(P_CAMERA_DMA_BUFFER_INFO pBufInfo, int BufferType)		// allocate DMA buffer
{
	int i,size;
    int sizeY,sizeC;

	RETAILMSG(CAM_INOUT,(TEXT("++++++++++++++++++CameraPrepareBuffer\n")));


    if(BufferType == VIDEO_CAPTURE_BUFFER)
    {
    	size = CalculateBufferSize(Video_Buffer.Width, Video_Buffer.Height, Video_Buffer.Format);
		Video_Buffer.FrameSize = size;
    	Video_Buffer.Size = size * MAX_HW_FRAMES;
		RETAILMSG(CAM_MSG,(TEXT("Video_Buffer.Width=%d Video_Buffer.Height=%d Video_Buffer.Size=%d  Video_Buffer.Format=%d\n"),Video_Buffer.Width, Video_Buffer.Height, Video_Buffer.Size, Video_Buffer.Format));

		if(Video_Buffer.Size > CAPTURE_BUFFER_SIZE)
		{
			RETAILMSG(CAM_ERR,(TEXT("Video size is larger than buffer size\n")));
			return FALSE;
		}

		for(i=0;i<MAX_HW_FRAMES;i++)
		{
		    pBufInfo[i].VirtAddr = (DWORD)pCodecVirtAddr + size*i;
		    pBufInfo[i].size = size;
		    pBufInfo[i].pY = (DWORD*)((DWORD)(PhysCodecAddr.LowPart) + size*i);
		}

		if(OUTPUT_CODEC_YCBCR420 == Video_Buffer.Format)
		{
			sizeY = Video_Buffer.Width*Video_Buffer.Height;
			sizeC = Video_Buffer.Width*Video_Buffer.Height/4;
			for(i=0;i<MAX_HW_FRAMES;i++)
			{
			    pBufInfo[i].pCb = (DWORD*)((DWORD)pBufInfo[i].pY + sizeY);
			    pBufInfo[i].pCr = (DWORD*)((DWORD)pBufInfo[i].pCb + sizeC);
			}
		}

    }
    else if(BufferType == STILL_CAPTURE_BUFFER)
    {
    	size = CalculateBufferSize(Still_Buffer.Width, Still_Buffer.Height, Still_Buffer.Format);
    	Still_Buffer.FrameSize = size;
		Still_Buffer.Size = size;
		RETAILMSG(CAM_MSG,(TEXT("Still_Buffer.Width=%d Still_Buffer.Height=%d Still_Buffer.Size=%d  Still_Buffer.Format=%d\n"),Still_Buffer.Width, Still_Buffer.Height, Still_Buffer.Size, Still_Buffer.Format));


		if(Still_Buffer.Size > CAPTURE_BUFFER_SIZE)
		{
			RETAILMSG(CAM_ERR,(TEXT("Still size is larger than buffer size\n")));
			return FALSE;
		}

	    pBufInfo[0].VirtAddr = (DWORD)pCodecVirtAddr;
	    pBufInfo[0].size = size;
	    pBufInfo[0].pY = (DWORD*)(PhysCodecAddr.LowPart);


		if(OUTPUT_CODEC_YCBCR420 == Still_Buffer.Format)
		{
			sizeY = Still_Buffer.Width*Still_Buffer.Height;
			sizeC = Still_Buffer.Width*Still_Buffer.Height/4;
		    pBufInfo[0].pCb = (DWORD*)((DWORD)pBufInfo[0].pY + sizeY);
		    pBufInfo[0].pCr = (DWORD*)((DWORD)pBufInfo[0].pCb + sizeC);

		}
    }
    else if(BufferType == PREVIEW_CAPTURE_BUFFER)
    {
		size = CalculateBufferSize(Preview_Buffer.Width, Preview_Buffer.Height, Preview_Buffer.Format);
		Preview_Buffer.FrameSize = size;
    	Preview_Buffer.Size = size * MAX_HW_FRAMES;
		RETAILMSG(CAM_MSG,(TEXT("Preview_Buffer.Width=%d Preview_Buffer.Height=%d Preview_Buffer.Size=%d Preview_Buffer.Format=%d\n"),Preview_Buffer.Width, Preview_Buffer.Height, Preview_Buffer.Size, Preview_Buffer.Format));

		if(Preview_Buffer.Size > PREVIEW_BUFFER_SIZE)
		{
			RETAILMSG(CAM_ERR,(TEXT("Preview size is larger than buffer size\n")));
			return FALSE;
		}

		for(i=0;i<MAX_HW_FRAMES;i++)