s3c6410_disp.cpp

SAMSUNG S3C6410 CPU BSP for winmobile6

	// Request FIMD H/W Resource to Video Engine Driver
	if ( !DeviceIoControl(m_hVideoDrv, IOCTL_SVE_RSC_REQUEST_FIMD_INTERFACE, NULL, 0, NULL, 0, &dwBytes, NULL) )
	{
		DISPDRV_ERR((_T("[DISPDRV:ERR] DevInitialize() : IOCTL_SVE_RSC_REQUEST_FIMD_INTERFACE Failed\n\r")));
		return FALSE;
	}

	// Request FIMD Win1 H/W Resource to Video Engine Driver for Primary Window
	if ( !DeviceIoControl(m_hVideoDrv, IOCTL_SVE_RSC_REQUEST_FIMD_WIN1, NULL, 0, NULL, 0, &dwBytes, NULL) )
	{
		DISPDRV_ERR((_T("[DISPDRV:ERR] DevInitialize() : IOCTL_SVE_RSC_REQUEST_FIMD_WIN1 Failed\n\r")));
		return FALSE;
	}

	// Frame Buffer
	m_VideoMemoryPhysicalBase = IMAGE_FRAMEBUFFER_PA_START;
	m_VideoMemorySize = IMAGE_FRAMEBUFFER_SIZE;

	m_VideoMemoryVirtualBase = (DWORD)VirtualAlloc(NULL, m_VideoMemorySize, MEM_RESERVE, PAGE_NOACCESS);

	if (NULL == VirtualCopy((void *)m_VideoMemoryVirtualBase, (void *)(m_VideoMemoryPhysicalBase>>8), m_VideoMemorySize, PAGE_READWRITE | PAGE_NOCACHE | PAGE_PHYSICAL))
	{
		DISPDRV_ERR((_T("[DISPDRV:ERR] AllocResource() : m_VideoMemoryVirtualBase VirtualCopy() Failed : %x\n\r"),	GetLastError()));
		return FALSE;
	}

	DISPDRV_INF((_T("[DISPDRV:INF] m_VideoMemoryPhysicalBase = 0x%08x\n\r"), m_VideoMemoryPhysicalBase));
	DISPDRV_INF((_T("[DISPDRV:INF] m_VideoMemoryVirtualBase = 0x%08x\n\r"), m_VideoMemoryVirtualBase));
	DISPDRV_INF((_T("[DISPDRV:INF] m_VideoMemorySize = 0x%08x\n\r"), m_VideoMemorySize));

	// Allocate SurfaceHeap
	m_pVideoMemoryHeap = new SurfaceHeap(m_VideoMemorySize, m_VideoMemoryVirtualBase, NULL, NULL);
	if(!m_pVideoMemoryHeap)
	{
		DISPDRV_ERR((_T("[DISPDRV:ERR] S3C6410Disp() : SurfaceHeap() allocate Fail\n\r")));
		return FALSE;
	}

	DISPDRV_MSG((_T("[DISPDRV] --AllocResource()\n\r")));

	return TRUE;
}


void
S3C6410Disp::ReleaseResource(void)
{
	DISPDRV_MSG((_T("[DISPDRV] ++S3C6410Disp::ReleaseResource()\n\r")));

	DWORD dwBytes;

	if (m_pVideoMemoryHeap != NULL)
	{
		delete m_pVideoMemoryHeap;
	}

	if (m_VideoMemoryVirtualBase != NULL)
	{
		VirtualFree((LPVOID)m_VideoMemoryVirtualBase, 0, MEM_RELEASE);
	}

	if (m_pDispConReg != NULL)
	{
		DrvLib_UnmapIoSpace((PVOID)m_pDispConReg);
		m_pDispConReg = NULL;
	}

	if (m_pGPIOReg != NULL)
	{
		DrvLib_UnmapIoSpace((PVOID)m_pGPIOReg);
		m_pGPIOReg = NULL;
	}

	if (m_pSPIReg != NULL)
	{
		DrvLib_UnmapIoSpace((PVOID)m_pSPIReg);
		m_pSPIReg = NULL;
	}

	// Release FIMD Win1 H/W Resource to Video Engine Driver for Primary Window
	if ( !DeviceIoControl(m_hVideoDrv, IOCTL_SVE_RSC_RELEASE_FIMD_WIN1, NULL, 0, NULL, 0, &dwBytes, NULL) )
	{
		DISPDRV_ERR((_T("[DISPDRV:ERR] DevInitialize() : IOCTL_SVE_RSC_RELEASE_FIMD_WIN1 Failed\n\r")));
	}

	// Release FIMD H/W Resource to Video Engine Driver
	if ( !DeviceIoControl(m_hVideoDrv, IOCTL_SVE_RSC_RELEASE_FIMD_INTERFACE, NULL, 0, NULL, 0, &dwBytes, NULL) )
	{
		DISPDRV_ERR((_T("[DISPDRV:ERR] DevInitialize() : IOCTL_SVE_RSC_RELEASE_FIMD_INTERFACE Failed\n\r")));
	}

	// Close Video Engine Driver
	if (m_hVideoDrv!= INVALID_HANDLE_VALUE)
	{
		CloseHandle(m_hVideoDrv);
		m_hVideoDrv = INVALID_HANDLE_VALUE;
	}

	DISPDRV_MSG((_T("[DISPDRV] --S3C6410Disp::ReleaseResource()\n\r")));
}


BOOL
S3C6410Disp::TVOutAllocResource(void)
{
	DISPDRV_MSG((_T("[DISPDRV] ++TVOutAllocResource()\n\r")));

	BOOL bRet = TRUE;
	DWORD dwBytes;

	// Request TV Scaler & TV Encoder H/W Resource to Video Engine Driver for TV Out
	if ( !DeviceIoControl(m_hVideoDrv, IOCTL_SVE_RSC_REQUEST_TVSCALER_TVENCODER, NULL, 0, NULL, 0, &dwBytes, NULL) )
	{
		DISPDRV_ERR((_T("[DISPDRV:ERR] TVOutAllocResource() : IOCTL_SVE_RSC_REQUEST_TVSCALER_TVENCODER Failed\n\r")));
		bRet = FALSE;
	}

	DISPDRV_MSG((_T("[DISPDRV] --TVOutAllocResource()\n\r")));

	return bRet;
}


BOOL
S3C6410Disp::TVOutReleaseResource(void)
{
	DISPDRV_MSG((_T("[DISPDRV] ++TVOutReleaseResource()\n\r")));

	BOOL bRet = TRUE;
	DWORD dwBytes;

	// Release TV Scaler & TV Encoder H/W Resource to Video Engine Driver
	if ( !DeviceIoControl(m_hVideoDrv, IOCTL_SVE_RSC_RELEASE_TVSCALER_TVENCODER, NULL, 0, NULL, 0, &dwBytes, NULL) )
	{
		DISPDRV_ERR((_T("[DISPDRV:ERR] TVOutReleaseResource() : IOCTL_SVE_RSC_RELEASE_TVSCALER_TVENCODER Failed\n\r")));
		bRet = FALSE;
	}

	DISPDRV_MSG((_T("[DISPDRV] --TVOutReleaseResource()\n\r")));

	return bRet;
}

// returns DD_OK for OK otherwise error code
// populates *pFormat, and *pPixelFormat
SCODE
S3C6410Disp::DetectPixelFormat(
				DWORD				dwCaps,			// in: DDSCAPS_xxx flags
				DDPIXELFORMAT*		pDDPF,			// in: Explicit pixel format or current mode
				EGPEFormat*			pFormat,
				EDDGPEPixelFormat*	pPixelFormat
				)
{
	SCODE rv = DDGPE::DetectPixelFormat(dwCaps, pDDPF, pFormat, pPixelFormat);

	if (rv == DDERR_UNSUPPORTEDFORMAT)
	{
		if(pDDPF->dwFlags & DDPF_FOURCC)
		{
			if( pDDPF->dwFourCC == FOURCC_I420 )
			{
				*pPixelFormat = (EDDGPEPixelFormat)ddgpePixelFormat_I420;
				*pFormat = gpe16Bpp;	// 12Bpp is not defined in GPE
				return DD_OK;
			}
			else	 if( pDDPF->dwFourCC == FOURCC_YVYU )
			{
				*pPixelFormat = (EDDGPEPixelFormat)ddgpePixelFormat_YVYU;
				*pFormat = gpe16Bpp;
				return DD_OK;
			}
			else	 if( pDDPF->dwFourCC == FOURCC_VYUY )
			{
				*pPixelFormat = (EDDGPEPixelFormat)ddgpePixelFormat_VYUY;
				*pFormat = gpe16Bpp;
				return DD_OK;
			}
		}

		return DDERR_UNSUPPORTEDFORMAT;
	}
	else
	{
		return rv;
	}
}

void
S3C6410Disp::SetDisplayPowerState(VIDEO_POWER_STATE PowerState)
{
	static BYTE * pVideoMemory = NULL;

	DISPDRV_MSG((_T("[DISPDRV] ++S3C6410Disp::SetDisplayPowerState(%d)\n\r"), PowerState));

	// If we're already in the appropriate state, just return
	if (m_VideoPowerState == PowerState)
	{
		DISPDRV_MSG((_T("[DISPDRV] SetDisplayPowerState() : Same as current State [%d]\n\r"), m_VideoPowerState));
		return;
	}

	if (PowerState == VideoPowerOn)
	{
		DISPDRV_MSG((_T("[DISPDRV] SetDisplayPowerState() : VideoPowerOn\n\r")));

		if (m_VideoPowerState == VideoPowerOn)
		{
			// Do Nothing
		}
		else		// from VideoPowerOff or VideoPowerSuspend
		{
			DevPowerOn();

			DynRotate(m_iRotate);

			m_CursorDisabled = FALSE;
			//CursorOn();	// in DynRotate()
			//m_CursorVisible = TRUE;	// in CursorOn()
		}

		m_VideoPowerState = VideoPowerOn;

	}
	else if (PowerState == VideoPowerOff)
	{
		DISPDRV_MSG((_T("[DISPDRV] SetDisplayPowerState() : VideoPowerOff\n\r")));

		if (m_VideoPowerState == VideoPowerOff)
		{
			// Do Nothing
		}
		else		// from VideoPowerOn or VideoPowerStandby
		{
			m_CursorDisabled = TRUE;
			CursorOff();

			// Turn Off Display Controller
			DevPowerOff();
		}

		m_VideoPowerState = VideoPowerOff;
	}
}


VIDEO_POWER_STATE
S3C6410Disp::GetDisplayPowerState(void)
{
	return m_VideoPowerState;
}


BOOL
S3C6410Disp::WaitForVerticalBlank(VB_STATUS Status)
{
	BOOL bRet = FALSE;

	bRet = DevWaitForVerticalBlank();

	return bRet;
}


DWORD
S3C6410Disp::GetScanLine(void)
{
	DWORD dwRet = 0;

	dwRet = DevGetScanLine();

	return dwRet;
}


BOOL
S3C6410Disp::OverlayAllocResource(BOOL bLocalPath)
{
	DISPDRV_MSG((_T("[DISPDRV] ++OverlayAllocResource(%d)\n\r"), bLocalPath));

	DWORD dwBytes;

	// Request FIMD Win0 H/W Resource to Video Engine Driver for Overlay Window
	if ( !DeviceIoControl(m_hVideoDrv, IOCTL_SVE_RSC_REQUEST_FIMD_WIN0, NULL, 0, NULL, 0, &dwBytes, NULL) )
	{
		DISPDRV_ERR((_T("[DISPDRV:ERR] OverlayAllocResource() : IOCTL_SVE_RSC_REQUEST_FIMD_WIN0 Failed\n\r")));
		goto AllocFail;
	}

	if (bLocalPath)
	{
		// Request Post Processor H/W Resource to Video Engine Driver for Overlay Window
		if ( !DeviceIoControl(m_hVideoDrv, IOCTL_SVE_RSC_REQUEST_POST, NULL, 0, NULL, 0, &dwBytes, NULL) )
		{
			DISPDRV_ERR((_T("[DISPDRV:ERR] OverlayAllocResource() : IOCTL_SVE_RSC_REQUEST_POST Failed\n\r")));
			goto AllocFail;
		}
	}

	DISPDRV_MSG((_T("[DISPDRV] --OverlayAllocResource()\n\r")));

	return TRUE;

AllocFail:

	// Release Partially Allocated Resource
	OverlayReleaseResource(bLocalPath);

	DISPDRV_ERR((_T("[DISPDRV:ERR] --OverlayAllocResource() : Failed\n\r")));

	return FALSE;
}


BOOL
S3C6410Disp::OverlayReleaseResource(BOOL bLocalPath)
{
	DISPDRV_MSG((_T("[DISPDRV] ++OverlayReleaseResource(%d)\n\r"), bLocalPath));

	BOOL bRet = TRUE;
	DWORD dwBytes;

	// Release FIMD Win0 H/W Resource to Video Engine Driver for Overlay Window
	if ( !DeviceIoControl(m_hVideoDrv, IOCTL_SVE_RSC_RELEASE_FIMD_WIN0, NULL, 0, NULL, 0, &dwBytes, NULL) )
	{
		DISPDRV_ERR((_T("[DISPDRV:ERR] OverlayReleaseResource() : IOCTL_SVE_RSC_RELEASE_FIMD_WIN0 Failed\n\r")));
		bRet = FALSE;
	}

	if (bLocalPath)
	{
		// Release Post Processor H/W Resource to Video Engine Driver for Overlay Window
		if ( !DeviceIoControl(m_hVideoDrv, IOCTL_SVE_RSC_RELEASE_POST, NULL, 0, NULL, 0, &dwBytes, NULL) )
		{
			DISPDRV_ERR((_T("[DISPDRV:ERR] OverlayReleaseResource() : IOCTL_SVE_RSC_RELEASE_POST Failed\n\r")));
			bRet = FALSE;
		}
	}

	DISPDRV_MSG((_T("[DISPDRV] --OverlayReleaseResource()\n\r")));

	return bRet;
}


BOOL
S3C6410Disp::OverlayInitialize(S3C6410Surf* pOverlaySurface, RECT *pSrc, RECT *pDest)
{
	BOOL bRet = TRUE;

	DISPDRV_MSG((_T("[DDHAL:INF] OverlayInitialize() (%d,%d) (%d,%d,%d,%d) (%d,%d,%d,%d)\n\r"),
					pOverlaySurface->Width(), pOverlaySurface->Height(),
					pSrc->left, pSrc->top, pSrc->right, pSrc->bottom,
					pDest->left, pDest->top, pDest->right, pDest->bottom));

	EnterCriticalSection(&m_csDevice);

	m_OverlayCtxt.pSurface = pOverlaySurface;

	// Driver support Overlay Source Clipping
	m_OverlayCtxt.uiSrcWidth = pSrc->right - pSrc->left;
	m_OverlayCtxt.uiSrcHeight = pSrc->bottom - pSrc->top;
	m_OverlayCtxt.uiSrcOffsetX = pSrc->left;
	m_OverlayCtxt.uiSrcOffsetY = pSrc->top;

	//  Driver support Overlay Destination Stretch
	m_OverlayCtxt.uiDstWidth = pDest->right - pDest->left;
	m_OverlayCtxt.uiDstHeight = pDest->bottom - pDest->top;
	m_OverlayCtxt.uiDstOffsetX = pDest->left;
	m_OverlayCtxt.uiDstOffsetY = pDest->top;

	switch(m_OverlayCtxt.pSurface->PixelFormat())
	{
	case ddgpePixelFormat_I420:	// YUV420
	case ddgpePixelFormat_YV12:	// YVU420
		m_OverlayCtxt.bLocalPath = TRUE;
		m_OverlayCtxt.dwWinMode = DISP_WIN0_POST_RGB;
		m_OverlayCtxt.dwBPPMode = DISP_24BPP_888;
		m_OverlayCtxt.dwPostSrcType = POST_SRC_YUV420;
		break;
	case ddgpePixelFormat_YUYV:	// YUV422 (YCbYCr)
	case ddgpePixelFormat_YUY2:	// YUV422 (YCbYCr)
		m_OverlayCtxt.bLocalPath = TRUE;
		m_OverlayCtxt.dwWinMode = DISP_WIN0_POST_RGB;
		m_OverlayCtxt.dwBPPMode = DISP_24BPP_888;
		m_OverlayCtxt.dwPostSrcType = POST_SRC_YUV422_CRYCBY;
		break;
	case ddgpePixelFormat_UYVY:	// YUV422 (CbYCrY)
		m_OverlayCtxt.bLocalPath = TRUE;
		m_OverlayCtxt.dwWinMode = DISP_WIN0_POST_RGB;
		m_OverlayCtxt.dwBPPMode = DISP_24BPP_888;
		m_OverlayCtxt.dwPostSrcType = POST_SRC_YUV422_YCRYCB;
		break;
	case ddgpePixelFormat_YVYU:	// YUV422 (YCrYCb)
		m_OverlayCtxt.bLocalPath = TRUE;
		m_OverlayCtxt.dwWinMode = DISP_WIN0_POST_RGB;
		m_OverlayCtxt.dwBPPMode = DISP_24BPP_888;
		m_OverlayCtxt.dwPostSrcType = POST_SRC_YUV422_CBYCRY;
		break;
	case ddgpePixelFormat_VYUY:	// YUV422 (CrYCbY)
		m_OverlayCtxt.bLocalPath = TRUE;
		m_OverlayCtxt.dwWinMode = DISP_WIN0_POST_RGB;
		m_OverlayCtxt.dwBPPMode = DISP_24BPP_888;
		m_OverlayCtxt.dwPostSrcType = POST_SRC_YUV422_YCBYCR;
		break;
	case ddgpePixelFormat_565:
		if (	(m_OverlayCtxt.uiSrcWidth == pOverlaySurface->Width())
			&& (m_OverlayCtxt.uiSrcHeight == pOverlaySurface->Height())
			&& (m_OverlayCtxt.uiDstWidth == pOverlaySurface->Width())
			&& (m_OverlayCtxt.uiDstHeight == pOverlaySurface->Height()))
		{
			// No Clipping and No Stretch, Don't Use Local Path for RGB
			m_OverlayCtxt.bLocalPath = FALSE;
			m_OverlayCtxt.dwWinMode = DISP_WIN0_DMA;
			m_OverlayCtxt.dwBPPMode = DISP_16BPP_565;
		}
		else
		{
			// Use Local Path for RGB
			m_OverlayCtxt.bLocalPath = TRUE;
			m_OverlayCtxt.dwWinMode = DISP_WIN0_POST_RGB;
			m_OverlayCtxt.dwBPPMode = DISP_24BPP_888;
			m_OverlayCtxt.dwPostSrcType = POST_SRC_RGB16;
		}
		break;
	//case ddgpePixelFormat_8880:	// FIMD can not support Packed RGB888
	case ddgpePixelFormat_8888:
		if (	(m_OverlayCtxt.uiSrcWidth == pOverlaySurface->Width())
			&& (m_OverlayCtxt.uiSrcHeight == pOverlaySurface->Height())
			&& (m_OverlayCtxt.uiDstWidth == pOverlaySurface->Width())
			&& (m_OverlayCtxt.uiDstHeight == pOverlaySurface->Height()))
		{
			// No Clipping and No Stretch, Don't Use Local Path for RGB
			m_OverlayCtxt.bLocalPath = FALSE;
			m_OverlayCtxt.dwWinMode = DISP_WIN0_DMA;
			m_OverlayCtxt.dwBPPMode = DISP_24BPP_888;
		}
		else
		{
			// Use Local Path for RGB
			m_OverlayCtxt.bLocalPath = TRUE;
			m_OverlayCtxt.dwWinMode = DISP_WIN0_POST_RGB;
			m_OverlayCtxt.dwBPPMode = DISP_24BPP_888;
			m_OverlayCtxt.dwPostSrcType = POST_SRC_RGB24;
		}
		break;
	}

	// Request H/W Resource for Overlay to Video Engine Driver
	if (OverlayAllocResource(m_OverlayCtxt.bLocalPath) == FALSE)
	{
		DISPDRV_ERR((_T("[DISPDRV:ERR] OverlayInitialize() : OverlayAllocResource() Failed\n\r")));
		bRet = FALSE;
		goto CleanUp;
	}

#if	0	// for Debug
	// Before Adjust Size and Position
	DISPDRV_ERR((_T("[%d, %d, %d, %d]->[%d, %d, %d, %d]\n\r"),
		m_OverlayCtxt.uiSrcWidth, m_OverlayCtxt.uiSrcHeight, m_OverlayCtxt.uiSrcOffsetX, m_OverlayCtxt.uiSrcOffsetY,
		m_OverlayCtxt.uiDstWidth, m_OverlayCtxt.uiDstHeight, m_OverlayCtxt.uiDstOffsetX, m_OverlayCtxt.uiDstOffsetY));
#endif

	// Adjust for Post Processor and FIMD restriction
	switch(m_OverlayCtxt.pSurface->PixelFormat())
	{
	case ddgpePixelFormat_I420:
	case ddgpePixelFormat_YV12:
		m_OverlayCtxt.uiSrcWidth = m_OverlayCtxt.uiSrcWidth-m_OverlayCtxt.uiSrcWidth%8;
		m_OverlayCtxt.uiSrcHeight = m_OverlayCtxt.uiSrcHeight-m_OverlayCtxt.uiSrcHeight%2;
		m_OverlayCtxt.uiSrcOffsetX = m_OverlayCtxt.uiSrcOffsetX-m_OverlayCtxt.uiSrcOffsetX%8;

		if (m_OverlayCtxt.uiSrcWidth < 8) m_OverlayCtxt.uiSrcWidth = 8;
		if (m_OverlayCtxt.uiSrcHeight < 4) m_OverlayCtxt.uiSrcHeight = 4;
		if (m_OverlayCtxt.uiDstHeight < 3) m_OverlayCtxt.uiDstHeight = 3;
		break;
	case ddgpePixelFormat_YUYV:
	case ddgpePixelFormat_YUY2:
	case ddgpePixelFormat_UYVY: