camera.cpp

S3C24A0的完整BSP包,对开发此芯片的开发者很有用.

			break;
		default :
			buffer_rgb = (U8 *)s24A0CAM->CIPRCLRSA1;
			break;
		}
	}
	RETAILMSG(MSG_EN_1,(_T("preview buf index = %d, status 0x%x\r\n"), temp, (s24A0CAM->CIPRSTATUS>>26)&3));

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

	RETAILMSG(MSG_EN_1,(_T("buffer_rgb = 0x%x\r\n"), buffer_rgb));

//	time = GetTickCount();
//	RETAILMSG(RETAIL_ON,(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 *)(IMAGE_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(RETAIL_ON,(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
	}

	return TRUE;
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
BOOL CIS_Deinit(DWORD hDeviceContext)
{
	BOOL bRet = TRUE;
	
	RETAILMSG(RETAIL_ON,(TEXT("CAMERA: CIS_Deinit\r\n")));
	
	Camif_Capture(CAPTURE_OFF, CAPTURE_OFF);

#if 0
	//DisplayEnable = 0;
	DRIVER_PREVIEW_ENABLE = 2;
#endif	

	CloseHandle(CameraThread);

	if(s24A0IOP)
		VirtualFree((void*)s24A0IOP, sizeof(S3C24A0_IOPORT_REG), MEM_RELEASE);
	if(s24A0CAM)
		VirtualFree((void*)s24A0CAM, sizeof(S3C24A0_CAM_REG), MEM_RELEASE);
	if(s24A0INT)
		VirtualFree((void*)s24A0INT, sizeof(S3C24A0_INTR_REG), MEM_RELEASE);
	if(s24A0PWR)
		VirtualFree((void*)s24A0PWR, sizeof(S3C24A0_CLKPWR_REG), MEM_RELEASE);
	if(s24A0IIC)
		VirtualFree((void*)s24A0IIC, sizeof(S3C24A0_IICBUS_REG), MEM_RELEASE);

	return TRUE;
} 



BOOL InitInterruptThread(LPVOID pvParam)
{
	DWORD   threadID;                         // thread ID
	BOOL	bSuccess;
	UINT32	Irq;

	CameraEvent = CreateEvent(NULL, FALSE, FALSE, NULL);

	if (!CameraEvent)
	{
		return FALSE;
	}

	// Obtain sysintr values from the OAL for the camera interrupt.
	//
	Irq = IRQ_CAMERA;
	if (!KernelIoControl(IOCTL_HAL_REQUEST_SYSINTR, &Irq, sizeof(UINT32), &gIntrCamera, sizeof(UINT32), NULL))
	{
		RETAILMSG(RETAIL_ON, (TEXT("ERROR: Failed to request the camera sysintr.\r\n")));
		gIntrCamera = SYSINTR_UNDEFINED;
		return(FALSE);
	}

	bSuccess = InterruptInitialize(gIntrCamera, CameraEvent, NULL, 0);
	if (!bSuccess) 
	{
		RETAILMSG(RETAIL_ON,(TEXT("Failed to initialize camera interrupt event\r\n")));
		return FALSE;
	}    

	CameraThread = CreateThread(NULL,
	                             0,
	                             (LPTHREAD_START_ROUTINE)CameraCaptureThread,
	                             pvParam,
	                             0,
	                             &threadID);

	if (NULL == CameraThread ) {
		RETAILMSG(RETAIL_ON,(TEXT("Create Camera Thread Fail\r\n")));
	}

	return TRUE;
}


BOOL CamClockOn(BOOL bOnOff)
{
RETAILMSG(RETAIL_ON, (TEXT("CamClockOn started..")));
	// Camera clock
	if (!bOnOff)
	{
		s24A0PWR->CLKCON &= ~((1<<23)|(1<<21)); // Camera clock disable
	}
	else 
	{
		Camera_Clock(CAM_CLK_DIV);
	
		s24A0PWR->CLKCON |= ((1<<23)|(1<<21));// Camera clock enable
		s24A0PWR->CLKCON |= (1<<12); // IIC clock enable
	}
	
	Delay(1000);

	RETAILMSG(RETAIL_ON, (TEXT("CamClockOn Completed..")));

	return TRUE;
}

BOOL CamGpioInit()
{
	s24A0IOP->PERIDAT_SLEEP0 |= (1<<25);
	s24A0IOP->PERIOEN_SLEEP1 &= ~(1<<15);
	
	//s24A0CAM->CIGCTRL |= (1<<30); // camera module reset signal to high level.
	
	  //PWDN control EINT6 GP6
		//13:12  01 for output
			s24A0IOP->GPCON_L &=~(1<<13);
			s24A0IOP->GPCON_L |=(1<<12);
			
			//0: mormal  1: power down
			s24A0IOP->GPDAT &=~(1<<6);
	
	
	
	
	
	
	RETAILMSG(RETAIL_ON, (TEXT("**Camera GPIO Init completed.\r\n")));
	
	return TRUE;
}

void CAM_IF_Reset()
{
	// This functin is used on power handler operation.
	// So, you should not use Kernel API functions such as  "Sleep()".

	//
	// Camera (FIMC2.0) I/F Reset
	//


          
			
		

	s24A0CAM->CIGCTRL |= (1<<29);	
	
	s24A0CAM->CIGCTRL |= (1<<31);

	// Don't modify this delay time
	Delay(1000);
		
	s24A0CAM->CIGCTRL &= ~(1<<31);

	// Wait for Camera module initialization
	Delay(1000);

	// PCLK Polarity setting //TBDA check if required
	s24A0CAM->CIGCTRL |= (1<<26);	

	RETAILMSG(RETAIL_ON,(TEXT("Camera I/F Reset done\r\n")));	
}	

void Camera_Module_Reset()
{
	s24A0CAM->CIGCTRL &= ~(1<<30);

	// Don't modify this delay time	
	Delay(100);

	RETAILMSG(RETAIL_ON,(TEXT("External Camera Module Reset\r\n")));	
}

void CamReset(void)
{
	//apr ++ do this for ITU 656 format
	//s24A0CAM->CISRCFMT |= (1<<31);	
	//apr --

	//Delay(100);
	
	//s24A0CAM->CIGCTRL |= (1<<31); // camera I/F soft reset
	//Delay(100);
	//s24A0CAM->CIGCTRL &= ~(1<<31);

	//s24A0CAM->CIGCTRL |= (1<<26); 		//| (1<<29); // XciPCLK Polarity setting
	
	//s24A0CAM->CIGCTRL &= ~((1<<30)|(1<<23)); // external camera reset assertion (S5X532, S5X433, AU70H = low active)
	//Delay(1000);
	//s24A0CAM->CIGCTRL |= ((1<<30)|(1<<23)); // external camera reset deassertion
	//Delay(1000);

	
	        s24A0CAM->CIGCTRL|= (1<<31)|(1<<29); //camera I/F soft reset
			Delay(100);
			s24A0CAM->CIGCTRL&= ~(1<<31);
			
			s24A0CAM->CIGCTRL|=(1<<30);	//external camera reset assertion (ov9650 =high active)	
			Delay(1000);
			s24A0CAM->CIGCTRL&=~(1<<30);		//external camera reset deassertion	
	        Delay(1000);
			
			s24A0CAM->CIGCTRL&=~(1<<26);  // XciPCLK Polarity setting
			s24A0CAM->CIGCTRL&=~(1<<25);  // XciVSYNC Polarity setting
			s24A0CAM->CIGCTRL&=~(1<<24);  // XciHREF Polarity setting
			
			//00: ycbcr  01:ycrcb
			s24A0CAM->CISRCFMT &= ~(1<<15); 	
			s24A0CAM->CISRCFMT &= ~(1<<14);
	
	
	
	
	RETAILMSG(RETAIL_ON,(TEXT("Camreset completed..\r\n")));	
}

BOOL Cam_Init()
{
	// Camera IO setup
	CamGpioInit();

	//Initialize the IIC
	CamIIC_open();

	//Camera i/f reset
	//CAM_IF_Reset();
		
	// Camera Clock setup
	CamClockOn(TRUE);

	// Camera Module Reset
	CamReset();
	//Camera_Module_Reset();	

	// Set register of camera module through IIC 
	Camera_Initialize();	

	RETAILMSG(RETAIL_ON,(_T("Camera_Initialize().. done\r\n")));

	if (image_size == 1)
		CamInit(QCIF_XSIZE, QCIF_YSIZE, QCIF_XSIZE, QCIF_YSIZE, 112, 20, COPIFRAMEBUFFER_B, COPIFRAMEBUFFER_A);
	else if (image_size == 2)
		CamInit(CIF_XSIZE, CIF_YSIZE, QCIF_XSIZE, QCIF_YSIZE, 112, 20, COPIFRAMEBUFFER_B, COPIFRAMEBUFFER_A);

	RETAILMSG(RETAIL_ON,(_T("CamInit().. done\r\n")));

	//Camera has been initialized
	bPowered 	= TRUE;
	
	return TRUE;
}


DWORD CIS_Init(DWORD dwContext)
{	
	//Added by APR ++
	DWORD			dwStatus, dwSize, dwType;
	TCHAR			szName[16];
	HKEY			hkDevice;
	PCAM_INFO		pCamInfo		= NULL;

	RETAILMSG(RETAIL_ON, (_T("CIS_Init\r\n")));

	// get our activation information
	dwStatus = RegOpenKeyEx(HKEY_LOCAL_MACHINE, (LPCTSTR) dwContext, 0, 0, &hkDevice);
	if(dwStatus != ERROR_SUCCESS)
	{
		RETAILMSG(RETAIL_ON, (_T("CIS_Init: OpenDeviceKey('%s') failed %u\r\n"), dwContext, dwStatus));
		return 0;
	}
	
	dwSize = sizeof(szName);
	dwStatus = RegQueryValueEx(hkDevice, TEXT("Name"), NULL, &dwType, (LPBYTE) szName, &dwSize);
	if(dwStatus != ERROR_SUCCESS || dwType != REG_SZ) 
	{
		RETAILMSG(RETAIL_ON, (_T("CIS_Init: RegQueryValueEx('%s', '%s') failed %u\r\n"),
			dwContext, REG_SZ, dwStatus));
		RegCloseKey(hkDevice);
		return 0;
	}
	RETAILMSG(RETAIL_ON, (_T("CIS_Init: device name is '%s'\r\n"), szName));
	RegCloseKey(hkDevice);
	//APR --

	// 1. Virtual Alloc
	Virtual_Alloc();
	
	Cam_Init();

	//Added by APR ++
	pCamInfo = (PCAM_INFO)LocalAlloc(LPTR, sizeof(CAM_INFO));
    	if (NULL == pCamInfo)						//check that LocalAlloc succeeded
	{
		RETAILMSG(RETAIL_ON, (TEXT("Error allocating memory for pCamInfo, CIS_Init failed\n\r")));
		return(NULL);
    	}
	//APR --
	
	//Added by APR ++
	InitializeCriticalSection(&(pCamInfo->csDevice));
	LOCK(pCamInfo);
	sCurrentDx						= D0;						//initial power state is full on
	pCamInfo->dwInactivityTimeout		= DEVICE_ACTIVITY_TIMEOUT;	//inactivity timeout
	pCamInfo->fBoostRequested		= FALSE;					//initially false
	pCamInfo->fReductionRequested	= FALSE;						//initially false
	pCamInfo->hActivityThread		= NULL;						//thread not created yet
	pCamInfo->bKillActivityThread	= FALSE;					//false so that the thread doesn't die immediately on creation
	_tcscpy(pCamInfo->szName, szName);					//copy the name of device as in registry
	pCamInfo->hevCamActivity		= CreateEvent(NULL, FALSE, FALSE, CAM_ACTIVITY_EVENT);
	pCamInfo->hevKillCamActivity	= CreateEvent(NULL, FALSE, FALSE, CAM_ACTIVITY_KILL_EVENT);
	//check if event creations succeeded
	if((NULL == pCamInfo->hevCamActivity) || (NULL == pCamInfo->hevKillCamActivity))
	{
		RETAILMSG(RETAIL_ON, (TEXT("Error creating activity event. CIS_Init failed.\n\r")));
		UNLOCK(pCamInfo);
        	return NULL;
	}
	//

	if (!InitInterruptThread(pCamInfo))
	{
        	RETAILMSG(RETAIL_ON,(TEXT("Fail to initialize camera interrupt event\r\n")));
        	return FALSE;
    	}    

	//start the activity thread here APR 26 May 2004
	if(NULL == pCamInfo->hActivityThread)
	{
		if(FALSE == StartActivityThread(pCamInfo))
		{
			RETAILMSG(RETAIL_ON, (TEXT("Error creating activity thread. CIS_Init failed.\n\r")));
			UNLOCK(pCamInfo);
			return NULL;
		}
	}
	
	UNLOCK(pCamInfo);		
	//APR --

	mInitialized = TRUE;
	return (DWORD)pCamInfo;
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
BOOL CIS_IOControl(DWORD hOpenContext, 
				   DWORD dwCode, 
				   PBYTE pBufIn, 
				   DWORD dwLenIn, 
				   PBYTE pBufOut, 
				   DWORD dwLenOut, 
				   PDWORD pdwActualOut)
{
	BOOL RetVal = TRUE;
	DWORD dwErr = ERROR_SUCCESS;    
	static unsigned int time=0,old_time=0;
	BOOL  bRc	= TRUE;
	PCAM_INFO pCamInfo = 0;

	pCamInfo = (PCAM_INFO) hOpenContext;
	if(NULL == pCamInfo)
		return FALSE;

	if(FALSE == bPowered)
	{
		//Reinitialize the camera after the power up
		Cam_Init();
		Sleep(10);
		bPowered = TRUE;
		if(FALSE == bClosed)
		{
#if 1
			if (DRIVER_PREVIEW_ENABLE == 1)
			{			
				Camif_Capture(CAPTURE_ON, CAPTURE_OFF);
			} 
			else if (DRIVER_PREVIEW_ENABLE == 2)	
			{
				Camif_Capture(CAPTURE_OFF, CAPTURE_ON);
			}
#else
			Camif_Capture(CAPTURE_ON, CAPTURE_ON);
#endif
			frame_count = 0;		// for MPEG4
			bClosed = FALSE;
			RETAILMSG(RETAIL_ON, (TEXT("Camera was not closed.. \n")));
		}
	}

	switch (dwCode)
	{
		//Added by APR ++
		// Power Management IOCTLs        
	case IOCTL_POWER_CAPABILITIES:
		{
			RETAILMSG(RETAIL_ON, (TEXT("#####CAMERA::CIS_IOControl:ioctl_power_capabilities\n")));
			PPOWER_CAPABILITIES ppc;
			
			if((NULL == pdwActualOut) || (NULL == pBufOut) || (dwLenOut < sizeof(POWER_CAPABILITIES)))
			{
				bRc = FALSE;
				dwErr = ERROR_INVALID_PARAMETER;
				break;
			}
			
			ppc = (PPOWER_CAPABILITIES)pBufOut;
			
			memset(ppc, 0, sizeof(POWER_CAPABILITIES));
			
			ppc->DeviceDx = 0x11;	// support D0 and D4 (no D1, D2 and D3)
			
			// no wake
			// no inrush
			
			// Report our power consumption in uAmps rather than mWatts. 
			ppc->Flags = POWER_CAP_PREFIX_MICRO | POWER_CAP_UNIT_AMPS;
			
			ppc->Power[D0] = 25000;
			
			*pdwActualOut = sizeof(POWER_CAPABILITIES);
		}
		break;
	case IOCTL_POWER_SET:
		RETAILMSG(RETAIL_ON, (TEXT("#####CAMERA::CIS_IOControl:ioctl_power_set\n")));