jpgdriver.c

SAMSUNG S3C6410 CPU BSP for winmobile6

*Implementation Notes: JPEG_IOControl sends commands to initiate different
*                       operations like Init,Decode and Deinit.The test
*                       application uses the DeviceIOControl function to
*                       specify an operation to perform
-----------------------------------------------------------------------------*/
BOOL
JPG_IOControl(
    DWORD OpenHandle,
    DWORD dwIoControlCode,
    PBYTE pInBuf,
    DWORD nInBufSize,
    PBYTE pOutBuf,
    DWORD nOutBufSize,
    PDWORD pBytesReturned
    )
{
	S3C6410_JPG_CTX *JPGRegCtx;
	JPG_DEC_PROC_PARAM *DecReturn;
	JPG_ENC_PROC_PARAM *EncParam;
	BOOL	result = TRUE;
	DWORD	ret;

	printD("DD::IOCTL\n");
	JPGRegCtx = (S3C6410_JPG_CTX *)OpenHandle;

	if(PowerChange == TRUE){
		RETAILMSG(1, (TEXT("DD::Power state is changed after open\r\n")));
		return FALSE;
	}

	if(!JPGRegCtx){
		RETAILMSG(1, (TEXT("DD::JPG Invalid Input Handle\r\n")));
		return FALSE;
	}

	ret = LockJPGMutex();
	if(!ret){
		RETAILMSG(1, (TEXT("DD::JPG Mutex Lock Fail\r\n")));
		return FALSE;
	}

	switch ( dwIoControlCode ) {

	case IOCTL_JPG_DECODE:
			printD("DD::IOCTL_JPEG_DECODE\n");
			DecReturn = (JPG_DEC_PROC_PARAM *)pBytesReturned;
			result = decodeJPG(JPGRegCtx, DecReturn);
			printD("DD::width : %d hegiht : %d size : %d\n",
				    DecReturn->width, DecReturn->height, DecReturn->dataSize);
			break;

	case IOCTL_JPG_ENCODE:
			printD("DD::IOCTL_JPEG_ENCODE\n");
			EncParam = (JPG_ENC_PROC_PARAM *)pBytesReturned;
			printD("DD::width : %d hegiht : %d enctype : %d quality : %d\n",
				    EncParam->width, EncParam->height, EncParam->encType, EncParam->quality);

			result = encodeJPG(JPGRegCtx, EncParam);
			printD("DD::encoded file size : %d\n", EncParam->fileSize);
			break;

	case IOCTL_JPG_GET_STRBUF:
			printD("DD::IOCTL_JPG_GET_STRBUF\n");
		#if	(_WIN32_WCE >= 600)
			JPGRegCtx->callerProcess = (HANDLE) GetDirectCallerProcessId();
			JPGRegCtx->strUserBuf = (PBYTE) VirtualAllocCopyEx((HANDLE) GetCurrentProcessId(),		// HANDLE hSrcProc
			                                							JPGRegCtx->callerProcess,	// HANDLE hDstProc
			                                							(LPVOID)JPGRegCtx->v_pJPGData_Buff,
			                                							JPG_STREAM_BUF_SIZE,
			                                							PAGE_READWRITE);
			printD("DD::strUserBuf : 0x%x CallerProcessID : 0x%x\n", JPGRegCtx->strUserBuf, JPGRegCtx->callerProcess);
			*((UINT *)pOutBuf) = (UINT) JPGRegCtx->strUserBuf;
		#else
			*((UINT *)pOutBuf) = (UINT) JPGRegCtx->v_pJPGData_Buff;
		#endif
			break;

	case IOCTL_JPG_GET_THUMB_STRBUF:
			printD("DD::IOCTL_JPG_GET_THUMB_STRBUF\n");
		#if	(_WIN32_WCE >= 600)
			JPGRegCtx->callerProcess = (HANDLE) GetDirectCallerProcessId();
			JPGRegCtx->strUserThumbBuf = (PBYTE) VirtualAllocCopyEx((HANDLE) GetCurrentProcessId(),		// HANDLE hSrcProc
			                                							JPGRegCtx->callerProcess,	// HANDLE hDstProc
			                                							(LPVOID)(JPGRegCtx->v_pJPGData_Buff+ JPG_STREAM_BUF_SIZE),
			                                							JPG_STREAM_THUMB_BUF_SIZE,
			                                							PAGE_READWRITE);
			printD("DD::strUserThumbBuf : 0x%x CallerProcessID : 0x%x\n", JPGRegCtx->strUserThumbBuf, JPGRegCtx->callerProcess);
			*((UINT *)pOutBuf) = (UINT) JPGRegCtx->strUserThumbBuf;
		#else
			*((UINT *)pOutBuf) = (UINT) JPGRegCtx->v_pJPGData_Buff+ JPG_STREAM_BUF_SIZE;
		#endif
			break;


	case IOCTL_JPG_GET_FRMBUF:
			printD("DD::IOCTL_JPG_GET_FRMBUF\n");
		#if	(_WIN32_WCE >= 600)
			JPGRegCtx->callerProcess = (HANDLE) GetDirectCallerProcessId();
			JPGRegCtx->frmUserBuf = (PBYTE) VirtualAllocCopyEx((HANDLE) GetCurrentProcessId(),		// HANDLE hSrcProc
			                                							JPGRegCtx->callerProcess,	// HANDLE hDstProc
			                                							(LPVOID)(JPGRegCtx->v_pJPGData_Buff + JPG_STREAM_BUF_SIZE + JPG_STREAM_THUMB_BUF_SIZE),
			                                							JPG_FRAME_BUF_SIZE,
			                                							PAGE_READWRITE);
			printD("DD::frmUserBuf : 0x%x CallerProcessID : 0x%x\n", JPGRegCtx->frmUserBuf, JPGRegCtx->callerProcess);
			*((UINT *)pOutBuf) = (UINT) JPGRegCtx->frmUserBuf;
		#else
			*((UINT *)pOutBuf) = (UINT) JPGRegCtx->v_pJPGData_Buff + JPG_STREAM_BUF_SIZE + JPG_STREAM_THUMB_BUF_SIZE;
		#endif
			break;
		
	case IOCTL_JPG_GET_PHY_FRMBUF:
			*((UINT *)pOutBuf) = (UINT)JPG_DATA_BASE_ADDR + JPG_STREAM_BUF_SIZE + JPG_STREAM_THUMB_BUF_SIZE;
			printD("IOCTL_JPG_GET_PHY_FRMBUF : 0x%x\n", JPG_DATA_BASE_ADDR + JPG_STREAM_BUF_SIZE + JPG_STREAM_THUMB_BUF_SIZE);
			break;

	
	case IOCTL_JPG_GET_THUMB_FRMBUF:
			printD("DD::IOCTL_JPG_GET_THUMB_FRMBUF\n");
		#if	(_WIN32_WCE >= 600)
			JPGRegCtx->callerProcess = (HANDLE) GetDirectCallerProcessId();
			JPGRegCtx->frmUserThumbBuf = (PBYTE) VirtualAllocCopyEx((HANDLE) GetCurrentProcessId(),		// HANDLE hSrcProc
			                                							JPGRegCtx->callerProcess,	// HANDLE hDstProc
			                                							(LPVOID)(JPGRegCtx->v_pJPGData_Buff+ JPG_STREAM_BUF_SIZE + JPG_STREAM_THUMB_BUF_SIZE + JPG_FRAME_BUF_SIZE),
			                                							JPG_FRAME_THUMB_BUF_SIZE,
			                                							PAGE_READWRITE);
			printD("DD::frmUserThumbBuf : 0x%x CallerProcessID : 0x%x\n", JPGRegCtx->frmUserThumbBuf, JPGRegCtx->callerProcess);
			*((UINT *)pOutBuf) = (UINT) JPGRegCtx->frmUserThumbBuf;
		#else
			*((UINT *)pOutBuf) = (UINT) JPGRegCtx->v_pJPGData_Buff+ JPG_STREAM_BUF_SIZE + JPG_STREAM_THUMB_BUF_SIZE + JPG_FRAME_BUF_SIZE;
		#endif
			break;

	case IOCTL_JPG_GET_RGBBUF:
		printD("DD::IOCTL_JPG_GET_RGBBUF\n");
		#if	(_WIN32_WCE >= 600)
			JPGRegCtx->callerProcess = (HANDLE) GetDirectCallerProcessId();
			JPGRegCtx->rgbBuf = (PBYTE) VirtualAllocCopyEx((HANDLE) GetCurrentProcessId(),		// HANDLE hSrcProc
			                                							JPGRegCtx->callerProcess,	// HANDLE hDstProc
			                                							(LPVOID)(JPGRegCtx->v_pJPGData_Buff+ JPG_STREAM_BUF_SIZE + JPG_STREAM_THUMB_BUF_SIZE+ JPG_FRAME_BUF_SIZE + JPG_FRAME_THUMB_BUF_SIZE),
			                                							JPG_RGB_BUF_SIZE,
			                                							PAGE_READWRITE);
			printD("DD::rgbBuf : 0x%x CallerProcessID : 0x%x\n", JPGRegCtx->rgbBuf, JPGRegCtx->callerProcess);
			*((UINT *)pOutBuf) = (UINT) JPGRegCtx->rgbBuf;
		#else
			*((UINT *)pOutBuf) = (UINT) JPGRegCtx->v_pJPGData_Buff+ JPG_STREAM_BUF_SIZE + JPG_STREAM_THUMB_BUF_SIZE+ JPG_FRAME_BUF_SIZE + JPG_FRAME_THUMB_BUF_SIZE;
		#endif
			break;
		
	case IOCTL_JPG_GET_PHY_RGBBUF:
			*((UINT *)pOutBuf) = (UINT)JPG_DATA_BASE_ADDR + JPG_STREAM_BUF_SIZE + JPG_STREAM_THUMB_BUF_SIZE+ JPG_FRAME_BUF_SIZE + JPG_FRAME_THUMB_BUF_SIZE;
			printD("IOCTL_JPG_GET_PHY_RGBBUF : 0x%x\n", JPG_DATA_BASE_ADDR + JPG_STREAM_BUF_SIZE + JPG_STREAM_THUMB_BUF_SIZE + JPG_FRAME_BUF_SIZE + JPG_FRAME_THUMB_BUF_SIZE);
			break;


	default : RETAILMSG(1, (TEXT("DD::JPG Invalid IOControl\r\n")));
	}


	UnlockJPGMutex();
	return result;
}

/*----------------------------------------------------------------------------
*Function: JPG_Write

*Parameters: 		dwContext		:
*Return Value:		True/False
*Implementation Notes: Initialize JPEG Hardware
-----------------------------------------------------------------------------*/
DWORD JPG_Write(
	DWORD OpenHandle,
	LPCVOID pBuffer,
	DWORD dwNumBytes
	)
{
    printD("DD::JPEG_Write \n");
	return 1;
}

/*----------------------------------------------------------------------------
*Function: JPEG_PowerUp

*Parameters: 		dwContext		:
*Return Value:		True/False
*Implementation Notes: Initialize JPEG Hardware
-----------------------------------------------------------------------------*/
void JPG_PowerUp(
	DWORD InitHandle
	)
{
	printD("DD::JPEG_PowerUp \n");
}

/*----------------------------------------------------------------------------
*Function: JPEG_PowerDown

*Parameters: 		dwContext		:
*Return Value:		True/False
*Implementation Notes: Initialize JPEG Hardware
-----------------------------------------------------------------------------*/
void JPG_PowerDown(
	DWORD InitHandle
	)
{
	printD("DD::JPEG_PowerDown(instanceNo : %d \n", instanceNo);
	if(instanceNo > 0){
		PowerChange = TRUE;
		Delay(1000);
	}

	JPGPowerControl(FALSE);

}

/*----------------------------------------------------------------------------
*Function: JPGPowerControl
*Implementation Notes: JPEG Power on/off
-----------------------------------------------------------------------------*/
static void JPGPowerControl(BOOL bOnOff)
{
	DWORD dwIPIndex = PWR_IP_JPEG;
	DWORD dwBytes;
	static int isOn = 0;

	printD("DD::JPEG Power Control\n");
	// JPEG clock
	if (!bOnOff)
	{
		if(isOn == 1)
		{
			printD("JPEG powerOFF\n");
			isOn = 0;
			s6410PWR->HCLK_GATE &= ~(1<<11); // JPEG clock disable
			s6410PWR->SCLK_GATE &= ~(1<<1); // JPEG clock disable
			if ( !DeviceIoControl(hPwrControl, IOCTL_PWRCON_SET_POWER_OFF, &dwIPIndex, sizeof(DWORD), NULL, 0, &dwBytes, NULL) )
			{
				RETAILMSG(1, (TEXT("DD::JPG IOCTL_PWRCON_SET_POWER_OFF Failed\r\n")));
			}
		}
	}
	else
	{
		if(isOn == 0)
		{
			printD("JPEG powerON\n");
			isOn = 1;

			if ( !DeviceIoControl(hPwrControl, IOCTL_PWRCON_SET_POWER_ON, &dwIPIndex, sizeof(DWORD), NULL, 0, &dwBytes, NULL) )
			{
				RETAILMSG(1, (TEXT("DD::JPG IOCTL_PWRCON_SET_POWER_ON Failed\r\n")));
			}

			s6410PWR->HCLK_GATE |= (1<<11); // JPEG clock enable
			s6410PWR->SCLK_GATE |= (1<<1); // JPEG clock enable
		}
	}
}


/*----------------------------------------------------------------------------
*Function: JPGSetClkDiv
*Implementation Notes: set JPG clock
-----------------------------------------------------------------------------*/
static BOOL JPGSetClkDiv(int divider)
{
	if ((divider < 1) || (divider > 16)) {
		RETAILMSG(1, (L"JPGSetClkDiv: JPG clock divider must be 1 ~ 16.\n\r"));
		return FALSE;
	}

	s6410PWR->CLK_DIV0 = (s6410PWR->CLK_DIV0 & ~(0xF << 24)) | ((divider - 1) << 24);

	return TRUE;
}

/*----------------------------------------------------------------------------
*Function: Delay
*Implementation Notes: delay during count milisecond
-----------------------------------------------------------------------------*/
static void Delay(UINT32 count)
{
	volatile int i, j = 0;
	volatile static int loop = S3C6410_APLL_CLK/100000;

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

/*----------------------------------------------------------------------------
*Function: JPEG_DllMain

*Parameters: 		DllInstance		:
					Reason			:
					Reserved		:
*Return Value:		True/False
*Implementation Notes: Entry point for JPEG.dll
-----------------------------------------------------------------------------*/
BOOL WINAPI
JPG_DllMain(HINSTANCE DllInstance, DWORD Reason, LPVOID Reserved)
{
    switch(Reason) {
        case DLL_PROCESS_ATTACH:
            DEBUGREGISTER(DllInstance);
            break;
    }
    return TRUE;
}