#include <windows.h>

#include <nkintr.h>
#include <oalintr.h>
//#include <p2.h>
#include <pm.h>
#include "pmplatform.h"

#include "s2440.h"
#include "camif.h"
#include "camera.h"

#define MSG_EN_1	0
#define MSG_EN_2	0
//#define RETAILMSG(a,b)	RETAILMSG(1,b)	

#define DOTNET_DRIVER 1 // 0:PPC, 1:CE.NET

#define CAPTURE_TIME		30
#define DISPLAY_SCHEDULE	0

#define U8	unsigned char
#define U16	unsigned short
#define U32	unsigned int

#define	PORT_A 1
#define	PORT_B 0

// Added 25 May 2004 for debug
#ifdef DEBUG
#define ZONE_INIT	1
#define ZONE_THREAD	1
#endif

#define	YCbCrtoR(Y,Cb,Cr)	(1000*Y + 1540*(Cr-128))/1000
#define	YCbCrtoG(Y,Cb,Cr)	(1000*Y - 459*(Cb-128) - 183*(Cr-128))/1000
#define	YCbCrtoB(Y,Cb,Cr)	(1000*Y + 1856*(Cb-128))/1000

volatile IOPreg 	*s2440IOP = (IOPreg *)IOP_BASE;
volatile CAMreg 	*s2440CAM = (CAMreg *)CAM_BASE;
volatile INTreg 	*s2440INT = (INTreg *)INT_BASE;
volatile CLKPWRreg	*s2440PWR = (CLKPWRreg *)CLKPWR_BASE;
volatile IICreg		*s2440IIC = (IICreg *)IIC_BASE;;

unsigned int DisplayTime = INFINITE;
//unsigned char DisplayEnable=0;
unsigned char buffer_num=0xff;		// ping pong buffer

unsigned char image_size = 2;				// 1: QCIF, 2:CIF (default)

//#define DRIVER_PREVIEW_ENABLE		2	// 0: onTimeTek, 1: Preview, 2:Samsung Camcorder
unsigned char DRIVER_PREVIEW_ENABLE = 2;	// 0: onTimeTek, 1: Preview, 2:Samsung Camcorder	

unsigned int frame_count=0;			// for MPEG4
DWORD Tick_GET_FRAME_CUR;
DWORD Tick_GET_FRAME_PREV;
DWORD Tick_COPY_FRAME;

HANDLE CameraThread;
HANDLE CameraEvent;
static BOOL mInitialized = FALSE;

unsigned char codec_flag=0;
unsigned char rgb_flag=0;
unsigned int y_address,cb_address,cr_address;
unsigned int rgb_address;
extern void Camera_Initialize();
extern volatile IOPreg *s2440IOP;
extern volatile IICreg *s2440IIC;

void Virtual_Alloc();						// Virtual allocation
void Camera_Clock(unsigned char divide);	// set default value
void Camif_Capture(int cap_a, int cap_b);	// A port, B port
void Display_Cam_Image(U32 pos_x, U32 pos_y, U32 size_x, U32 size_y, U8 port);
void Copy_Cam_Image(U8 * pBufOut, U32 size_x, U32 size_y, U8 port);
void Samsung_camcoder(U8 *pBufOut);
void Samsung_camcoder_pr(U8 *pBufOut);
void Buffer_codec_info_update();
void Buffer_preview_info_update();
BOOL Cam_Init();
BOOL CamClockOn(BOOL bOnOff);
//void CamCaptureStart(U32 mode);

void CamInit(U32 CoDstWidth, U32 CoDstHeight, U32 PrDstWidth, U32 PrDstHeight, 
			U32 WinHorOffset, U32 WinVerOffset,  U32 CoFrameBuffer, U32 PrFrameBuffer);

DWORD CameraCaptureThread(void);
BOOL InitInterruptThread();

CEDEVICE_POWER_STATE m_Dx;

#ifdef DEBUG
DBGPARAM dpCurSettings = {
    TEXT("CAMERA"), {
        TEXT("0"),TEXT("1"),TEXT("2"),TEXT("3"),
        TEXT("4"),TEXT("5"),TEXT("6"),TEXT("7"),
        TEXT("8"),TEXT("9"),TEXT("10"),TEXT("11"),
        TEXT("12"),TEXT("Function"),TEXT("Init"),TEXT("Error")},
    0x8000  // Errors only, by default
}; 
#endif


static void Delay(USHORT count)
{
	volatile int i, j = 0;
	volatile static int loop = S2440FCLK/100000;
	
	for(;count > 0;count--)
		for(i=0;i < loop; i++) { j++; }
}


/********************************************************
 CalculateBurstSize - Calculate the busrt lengths
 
 Description:	
 - dstHSize: the number of the byte of H Size.
 
*/
void CalculateBurstSize(unsigned int hSize,unsigned int *mainBurstSize,unsigned int *remainedBurstSize)
{
	unsigned int tmp;	
	tmp=(hSize/4)%16;
	switch(tmp) {
		case 0:
			*mainBurstSize=16;
			*remainedBurstSize=16;
			break;
		case 4:
			*mainBurstSize=16;
			*remainedBurstSize=4;
			break;
		case 8:
			*mainBurstSize=16;
			*remainedBurstSize=8;
			break;
		default: 
			tmp=(hSize/4)%8;
			switch(tmp) {
				case 0:
					*mainBurstSize=8;
					*remainedBurstSize=8;
					break;
				case 4:
					*mainBurstSize=8;
					*remainedBurstSize=4;
				default:
					*mainBurstSize=4;
					tmp=(hSize/4)%4;
					*remainedBurstSize= (tmp) ? tmp: 4;
					break;
			}
			break;
	}		    	    		
}

/********************************************************
 CalculatePrescalerRatioShift - none
 
 Description:	
 - none
 
*/
void CalculatePrescalerRatioShift(unsigned int SrcSize, unsigned int DstSize, unsigned int *ratio,unsigned int *shift)
{
	if(SrcSize>=64*DstSize) {
//		Uart_Printf("ERROR: out of the prescaler range: SrcSize/DstSize = %d(< 64)\r\n",SrcSize/DstSize);
		while(1);
	}
	else if(SrcSize>=32*DstSize) {
		*ratio=32;
		*shift=5;
	}
	else if(SrcSize>=16*DstSize) {
		*ratio=16;
		*shift=4;
	}
	else if(SrcSize>=8*DstSize) {
		*ratio=8;
		*shift=3;
	}
	else if(SrcSize>=4*DstSize) {
		*ratio=4;
		*shift=2;
	}
	else if(SrcSize>=2*DstSize) {
		*ratio=2;
		*shift=1;
	}
	else {
		*ratio=1;
		*shift=0;
	}    	
}

void Camera_Clock(unsigned char divide)
{
	unsigned int camclk;
	
	// Set camera clock for camera processor
	s2440PWR->rCAMDIVN = (s2440PWR->rCAMDIVN & ~(0x1f)) | (1<<4) | (divide & 0xf); // CAMCLK is divided..
	camclk = 48000000/(((s2440PWR->rCAMDIVN&0xf) + 1)*2);

	RETAILMSG(1,(TEXT("CAM clock:%d\r\n"),camclk));
}

/*
void CamCaptureStart(unsigned int mode)
{ 
	if(mode&CAM_CODEC_SCALER_CAPTURE_ENABLE_BIT) {
		s2440CAM->rCICOSCCTRL|=CAM_CODEC_SACLER_START_BIT;
	}
	
	if(mode&CAM_PVIEW_SCALER_CAPTURE_ENABLE_BIT) {
		s2440CAM->rCIPRSCCTRL|=CAM_PVIEW_SACLER_START_BIT;
	}
    
	s2440CAM->rCIIMGCPT|=(CAM_CAMIF_GLOBAL_CAPTURE_ENABLE_BIT|mode);
}
*/

void Camif_Capture(int cap_a, int cap_b)
{
	//RETAILMSG(1,(_T("Camif_Capture(%d, %d)\r\n"), cap_a, cap_b));
	// S3C2440A

	s2440CAM->rCIIMGCPT &= ~(CAM_CAMIF_GLOBAL_CAPTURE_ENABLE_BIT);

	if(cap_b == CAPTURE_ON) 
	{
		//Codec capture start
		s2440CAM->rCICOSCCTRL |=(CAM_CODEC_SACLER_START_BIT);
		s2440CAM->rCIIMGCPT |=(CAM_CAMIF_GLOBAL_CAPTURE_ENABLE_BIT)|(CAM_CODEC_SCALER_CAPTURE_ENABLE_BIT);
	} 
	else if (cap_b == CAPTURE_OFF)
	{
		s2440CAM->rCICOSCCTRL &= ~(CAM_CODEC_SACLER_START_BIT);
		s2440CAM->rCIIMGCPT &= ~(CAM_CODEC_SCALER_CAPTURE_ENABLE_BIT);
	}

	if(cap_a == CAPTURE_ON) 
	{  
		// Preview capture Start
		s2440CAM->rCIPRSCCTRL |=(CAM_PVIEW_SACLER_START_BIT);
		s2440CAM->rCIIMGCPT |=(CAM_CAMIF_GLOBAL_CAPTURE_ENABLE_BIT)|(CAM_PVIEW_SCALER_CAPTURE_ENABLE_BIT);
	}
	else if (cap_a == CAPTURE_OFF)
	{
		s2440CAM->rCIPRSCCTRL &= ~(CAM_PVIEW_SACLER_START_BIT);
		s2440CAM->rCIIMGCPT &= ~(CAM_PVIEW_SCALER_CAPTURE_ENABLE_BIT);
	}
	
	if ((cap_a == CAPTURE_ON) || (cap_b == CAPTURE_ON))
	{
		s2440CAM->rCIIMGCPT |= (CAM_CAMIF_GLOBAL_CAPTURE_ENABLE_BIT);
	}
	
}

DWORD CameraCaptureThread(void)
{
	unsigned char tmp=0;
	static unsigned int time,old_time;
	static unsigned int cam_intr;
	
	while(1)
	{
		WaitForSingleObject(CameraEvent, DisplayTime);
		
		RETAILMSG(MSG_EN_1,(_T("CameraCaptureThread(%d)++\r\n"), frame_count));

#if 0
		if (frame_count <= 2) {
			frame_count++;
			// Enable camera interrupt
			s2440INT->rINTSUBMSK &= ~(BIT_SUB_CAM_P|BIT_SUB_CAM_C);
			s2440INT->rINTMSK &= ~BIT_CAM;
			
			continue;
		}
#endif
		
		//if( DisplayEnable )
		{

			frame_count++;

			if (s2440INT->rINTSUBMSK & BIT_SUB_CAM_C)
			{
				cam_intr = BIT_SUB_CAM_C;
				//RETAILMSG(1,(_T("CAM_C, ts %d\r\n"), GetTickCount()));
			}
			else if (s2440INT->rINTSUBMSK & BIT_SUB_CAM_P)
			{
				cam_intr = BIT_SUB_CAM_P;
				//RETAILMSG(1,(_T("CAM_P, ts %d\r\n"), GetTickCount()));
			}
			
			
			// EINT20 to measure time
//			s2440IOP->rGPGDAT |= (1<<12);
//			time = GetTickCount();
//			RETAILMSG(1,(TEXT("+time:%d\r\n"),(time - old_time)));

			// delay for capture
			//Sleep(CAPTURE_TIME);			// polling mode

			// display the image	
			if ((DRIVER_PREVIEW_ENABLE == 1) & (cam_intr == BIT_SUB_CAM_P))
				Display_Cam_Image(64, 64, QCIF_XSIZE, QCIF_YSIZE, PORT_A);

			//else if (DRIVER_PREVIEW_ENABLE == 2)	
			if (cam_intr == BIT_SUB_CAM_C)
			{
				Buffer_codec_info_update();
			}

			if (cam_intr == BIT_SUB_CAM_P)
			{
				Buffer_preview_info_update();
			}
				
			// Enable camera interrupt
			s2440INT->rINTSUBMSK &= ~(BIT_SUB_CAM_P|BIT_SUB_CAM_C);
			s2440INT->rINTMSK &= ~BIT_CAM;

/*
			if (DRIVER_PREVIEW_ENABLE == 1)
				Camif_Capture(CAPTURE_ON, CAPTURE_OFF);
			else if (DRIVER_PREVIEW_ENABLE == 2)	
				Camif_Capture(CAPTURE_OFF, CAPTURE_ON);
*/
			
			// EINT20 to measure time			
//			s2440IOP->rGPGDAT &= ~(1<<12);
//			old_time = GetTickCount();
//			RETAILMSG(1,(TEXT("-time:%d\r\n"),(old_time-time)));
			
		}
	}
}



void Virtual_Alloc()
{

    // GPIO Virtual alloc
	s2440IOP = (volatile IOPreg *) VirtualAlloc(0,sizeof(IOPreg),MEM_RESERVE, PAGE_NOACCESS);
	if(s2440IOP == NULL) {
		RETAILMSG(1,(TEXT("For s2440IOP: VirtualAlloc failed!\r\n")));
	}
	else {
		if(!VirtualCopy((PVOID)s2440IOP,(PVOID)(IOP_BASE),sizeof(IOPreg),PAGE_READWRITE | PAGE_NOCACHE )) {
			RETAILMSG(1,(TEXT("For s2440IOP: VirtualCopy failed!\r\n")));
		}
	}
    // IIC Virtual alloc
	s2440IIC = (volatile IICreg *) VirtualAlloc(0,sizeof(IICreg),MEM_RESERVE, PAGE_NOACCESS);
	if(s2440IIC == NULL) {
		RETAILMSG(1,(TEXT("For s2440IIC: VirtualAlloc failed!\r\n")));
	}
	else {
		if(!VirtualCopy((PVOID)s2440IIC,(PVOID)(IIC_BASE),sizeof(IICreg),PAGE_READWRITE | PAGE_NOCACHE )) {
			RETAILMSG(1,(TEXT("For s2440IIC: VirtualCopy failed!\r\n")));
		}
	}
	
    // Camera Virtual alloc
	s2440CAM = (volatile CAMreg *) VirtualAlloc(0,sizeof(CAMreg),MEM_RESERVE, PAGE_NOACCESS);
	if(s2440CAM == NULL) {
		RETAILMSG(1,(TEXT("For s2440CAM: VirtualAlloc failed!\r\n")));
	}
	else {
		if(!VirtualCopy((PVOID)s2440CAM,(PVOID)(CAM_BASE),sizeof(CAMreg),PAGE_READWRITE | PAGE_NOCACHE )) {
			RETAILMSG(1,(TEXT("For s2440CAM: VirtualCopy failed!\r\n")));
		}
	}

	// Interrupt Virtual alloc
	s2440INT = (volatile INTreg *) VirtualAlloc(0,sizeof(INTreg),MEM_RESERVE, PAGE_NOACCESS);
	if(s2440INT == NULL) {
		RETAILMSG(1,(TEXT("For s2440INT: VirtualAlloc failed!\r\n")));
	}
	else {
		if(!VirtualCopy((PVOID)s2440INT,(PVOID)(INT_BASE),sizeof(INTreg),PAGE_READWRITE | PAGE_NOCACHE )) {
			RETAILMSG(1,(TEXT("For s2440INT: VirtualCopy failed!\r\n")));
		}
	}
	// PWM clock Virtual alloc
	s2440PWR = (volatile CLKPWRreg *) VirtualAlloc(0,sizeof(CLKPWRreg),MEM_RESERVE, PAGE_NOACCESS);
	if(s2440PWR == NULL) {
		RETAILMSG(1,(TEXT("For s2440PWR: VirtualAlloc failed!\r\n")));
	}
	else {
		if(!VirtualCopy((PVOID)s2440PWR,(PVOID)(CLKPWR_BASE),sizeof(CLKPWRreg),PAGE_READWRITE | PAGE_NOCACHE )) {
			RETAILMSG(1,(TEXT("For s2440PWR: VirtualCopy failed!\r\n")));
		}
	}
}

void Display_Cam_Image(U32 pos_x, U32 pos_y, U32 size_x, U32 size_y, U8 port)
{
	U8 *buffer_rgb;
	U32 y;
	int temp;
	
	//unsigned short *ptr = (unsigned short *)(FRAMEBUF_BASE+0x5dc0);
	
	static unsigned short transfer_data[QCIF_XSIZE*QCIF_YSIZE];
	static unsigned int time,old_time;
	
	//RETAILMSG(1,(_T("Display_Cam_Image()\r\n")));
	
//	if (port)
	{
		temp = (s2440CAM->rCIPRSTATUS>>26)&3;
		temp = (temp + 2) % 4;
		
		switch (temp)
		{
		case 0:
			buffer_rgb = (U8 *)s2440CAM->rCIPRCLRSA1;
			break;
		case 1:
			buffer_rgb = (U8 *)s2440CAM->rCIPRCLRSA2;
			break;
		case 2:
			buffer_rgb = (U8 *)s2440CAM->rCIPRCLRSA3;
			break;
		case 3:
			buffer_rgb = (U8 *)s2440CAM->rCIPRCLRSA4;
			break;
		default :
			buffer_rgb = (U8 *)s2440CAM->rCIPRCLRSA1;
			break;
		}
	}
	RETAILMSG(MSG_EN_1,(_T("preview buf index = %d\r\n"), temp));

#if (DOTNET_DRIVER)
	SetKMode(TRUE);
#endif
	
	buffer_rgb += VIRTUAL_OFFSET;

//	time = GetTickCount();
//	RETAILMSG(1,(TEXT("+:%d\r\n"),(time - old_time)));


#if 1
	for (y=0;y<(size_y-2);y++) // YCbCr 4:2:0 format
	{
		//memcpy((void *)(FRAMEBUF_BASE+0x5e00+y*240*2),(void *)buffer_rgb,(QCIF_XSIZE)*2);
		memcpy((void *)(FRAMEBUF_BASE+ (240*pos_y + pos_x) + y*240*2),(void *)buffer_rgb,(QCIF_XSIZE)*2);
		buffer_rgb += (QCIF_XSIZE*2);
	}
#endif

#if (DOTNET_DRIVER)
	SetKMode(FALSE);
#endif

//	old_time = GetTickCount();
//	RETAILMSG(1,(TEXT("-:%d\r\n"),(old_time - time)));

}



BOOL WINAPI  
DllEntry(HANDLE	hinstDLL, 
			DWORD dwReason, 
			LPVOID /* lpvReserved */)
{
	switch(dwReason)
	{
	case DLL_PROCESS_ATTACH:
		DEBUGREGISTER((HINSTANCE)hinstDLL);
		DEBUGMSG(ZONE_INIT,(TEXT("CAMERA: DLL_PROCESS_ATTACH\r\n")));
		return TRUE;
	case DLL_THREAD_ATTACH:
		DEBUGMSG(ZONE_THREAD,(TEXT("CAMERA: DLL_THREAD_ATTACH\r\n")));
		break;
	case DLL_THREAD_DETACH:
		DEBUGMSG(ZONE_THREAD,(TEXT("CAMERA: DLL_THREAD_DETACH\r\n")));
		break;
	case DLL_PROCESS_DETACH:
		DEBUGMSG(ZONE_INIT,(TEXT("CAMERA: DLL_PROCESS_DETACH\r\n")));
		break;
#ifdef UNDER_CE
	case DLL_PROCESS_EXITING:
		DEBUGMSG(ZONE_INIT,(TEXT("CAMERA: DLL_PROCESS_EXITING\r\n")));
		break;
	case DLL_SYSTEM_STARTED:
		DEBUGMSG(ZONE_INIT,(TEXT("CAMERA: DLL_SYSTEM_STARTED\r\n")));
		break;
#endif
	}