s3c6400_disp.cpp

Samsung公司S3C6400芯片的BSP源码包

		m_pTVEncReg = NULL;
	}

	// Close Power Control Driver
	if (m_hPowerControl != INVALID_HANDLE_VALUE)
	{
		CloseHandle(m_hPowerControl);
		m_hPowerControl = INVALID_HANDLE_VALUE;
	}

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


BOOL
S3C6400Disp::InitializeInterrupt(void)
{
	DWORD dwIRQ;

	DISPDRV_MSG((_T("[DISPDRV] ++S3C6400Disp::InitializeInterrupt()\n\r")));

	dwIRQ = IRQ_LCD1_FRAME;					// LCD VSYNC IRQ
	m_dwSysIntrDisp = SYSINTR_UNDEFINED;
	m_hInterruptDisp = NULL;

	if (!KernelIoControl(IOCTL_HAL_REQUEST_SYSINTR, &dwIRQ, sizeof(DWORD), &m_dwSysIntrDisp, sizeof(DWORD), NULL))
	{
		DISPDRV_ERR((_T("[DISPDRV:ERR] InitializeInterrupt() : IOCTL_HAL_REQUEST_SYSINTR DispCon Failed \n\r")));
		m_dwSysIntrDisp = SYSINTR_UNDEFINED;
		return FALSE;
	}

	m_hInterruptDisp = CreateEvent(NULL, FALSE, FALSE, NULL);
	if(NULL == m_hInterruptDisp)
	{
		DISPDRV_ERR((_T("[DISPDRV:ERR] InitializeInterrupt() : CreateEvent() DispCon Failed \n\r")));
		return FALSE;
	}

	if (!(InterruptInitialize(m_dwSysIntrDisp, m_hInterruptDisp, 0, 0)))
	{
		DISPDRV_ERR((_T("[DISPDRV:ERR] InitializeInterrupt() : InterruptInitialize() DispCon Failed \n\r")));
		return FALSE;
	}

	dwIRQ = IRQ_POST;					// Post Processor IRQ
	m_dwSysIntrPost = SYSINTR_UNDEFINED;
	m_hInterruptPost = NULL;

	if (!KernelIoControl(IOCTL_HAL_REQUEST_SYSINTR, &dwIRQ, sizeof(DWORD), &m_dwSysIntrPost, sizeof(DWORD), NULL))
	{
		DISPDRV_ERR((_T("[DISPDRV:ERR] InitializeInterrupt() : IOCTL_HAL_REQUEST_SYSINTR Post Failed \n\r")));
		m_dwSysIntrPost = SYSINTR_UNDEFINED;
		return FALSE;
	}

	m_hInterruptPost = CreateEvent(NULL, FALSE, FALSE, NULL);
	if(NULL == m_hInterruptPost)
	{
		DISPDRV_ERR((_T("[DISPDRV:ERR] InitializeInterrupt() : CreateEvent() Post Failed \n\r")));
		return FALSE;
	}

	if (!(InterruptInitialize(m_dwSysIntrPost, m_hInterruptPost, 0, 0)))
	{
		DISPDRV_ERR((_T("[DISPDRV:ERR] InitializeInterrupt() : InterruptInitialize() Post Failed \n\r")));
		return FALSE;
	}

	DISPDRV_MSG((_T("[DISPDRV] --S3C6400Disp::InitializeInterrupt()\n\r")));

	return TRUE;
}


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

	if (m_dwSysIntrDisp != SYSINTR_UNDEFINED)
	{
		InterruptDisable(m_dwSysIntrDisp);
	}

	if (m_hInterruptDisp != NULL)
	{
		CloseHandle(m_hInterruptDisp);
	}

	if (m_dwSysIntrDisp != SYSINTR_UNDEFINED)
	{
		KernelIoControl(IOCTL_HAL_RELEASE_SYSINTR, &m_dwSysIntrDisp, sizeof(DWORD), NULL, 0, NULL);
	}

	if (m_dwSysIntrPost != SYSINTR_UNDEFINED)
	{
		InterruptDisable(m_dwSysIntrPost);
	}

	if (m_hInterruptPost != NULL)
	{
		CloseHandle(m_hInterruptPost);
	}

	if (m_dwSysIntrDisp != SYSINTR_UNDEFINED)
	{
		KernelIoControl(IOCTL_HAL_RELEASE_SYSINTR, &m_dwSysIntrPost, sizeof(DWORD), NULL, 0, NULL);
	}

	DISPDRV_MSG((_T("[DISPDRV] --S3C6400Disp::DeinitInterrupt()\n\r")));
}


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

	DISPDRV_MSG((_T("[DISPDRV] ++S3C6400Disp::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	1
	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;
	}
#else
	if (PowerState == VideoPowerOn)
	{
		DISPDRV_MSG((_T("[DISPDRV] SetDisplayPowerState() : VideoPowerOn\n\r")));

		if (m_VideoPowerState == VideoPowerStandBy)
		{
			// 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 == VideoPowerStandBy)
	{
		DISPDRV_MSG((_T("[DISPDRV] SetDisplayPowerState() : VideoPowerStandBy\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 = VideoPowerStandBy;
	}
	else if (PowerState == VideoPowerOff)
	{
		DISPDRV_MSG((_T("[DISPDRV] SetDisplayPowerState() : VideoPowerOff\n\r")));

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

			// Turn Off Display Controller
			DevPowerOff();
		}

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

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

			// Turn Off Display Controller
			DevPowerOff();
		}

		m_VideoPowerState = VideoPowerSuspend;
	}
#endif
}


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


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

	if (m_VideoPowerState == VideoPowerOff)
	{
		// To Avoid System Hang in SystemIdle State
		// When Application access to DDraw API in SystemIdle State
		// System Hangs... (Maybe Display Driver in VideoPowerOff state)
		DISPDRV_INF((_T("[DISPDRV:INF] WaitForVerticalBlank() : Skipped in 'VideoPowerOff State'\n\r")));

		return FALSE;
	}
	else
	{
		EnterCriticalSection(&m_csDevice);

		bRet = DevWaitForVerticalBlank(Status);

		LeaveCriticalSection(&m_csDevice);

		return bRet;
	}
}


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

	if (m_VideoPowerState == VideoPowerOff)
	{
		// To Avoid System Hang in SystemIdle State
		// When Application access to DDraw API in SystemIdle State
		// System Hangs... (Maybe Display Driver in VideoPowerOff state)
		DISPDRV_INF((_T("[DISPDRV:INF] GetScanLine() : Skipped in 'VideoPowerOff State'\n\r")));
		return 0;
	}
	else
	{
		//EnterCriticalSection(&m_csDevice);		// Not so Critical

		dwRet = DevGetScanLine();

		//LeaveCriticalSection(&m_csDevice);		// Not so Critical

		return dwRet;
	}
}


void
S3C6400Disp::OverlayInitialize(S3C6400Surf* pOverlaySurface, RECT *pSrc, RECT *pDest)
{
	DISPDRV_INF((_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;

	// 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));

	// 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:
	case ddgpePixelFormat_YVYU:
	case ddgpePixelFormat_VYUY:
		m_OverlayCtxt.uiSrcWidth = m_OverlayCtxt.uiSrcWidth-m_OverlayCtxt.uiSrcWidth%2;
		m_OverlayCtxt.uiSrcHeight = m_OverlayCtxt.uiSrcHeight-m_OverlayCtxt.uiSrcHeight%2;
		m_OverlayCtxt.uiSrcOffsetX = m_OverlayCtxt.uiSrcOffsetX-m_OverlayCtxt.uiSrcOffsetX%2;

		if (m_OverlayCtxt.uiSrcWidth < 2) m_OverlayCtxt.uiSrcWidth = 2;
		if (m_OverlayCtxt.uiSrcHeight < 2) m_OverlayCtxt.uiSrcHeight = 2;
		break;
	case ddgpePixelFormat_565:
		m_OverlayCtxt.uiSrcWidth = m_OverlayCtxt.uiSrcWidth-m_OverlayCtxt.uiSrcWidth%2;
		m_OverlayCtxt.uiSrcHeight = m_OverlayCtxt.uiSrcHeight-m_OverlayCtxt.uiSrcHeight%2;
		m_OverlayCtxt.uiSrcOffsetX = m_OverlayCtxt.uiSrcOffsetX-m_OverlayCtxt.uiSrcOffsetX%2;

		m_OverlayCtxt.uiDstWidth = m_OverlayCtxt.uiDstWidth-m_OverlayCtxt.uiDstWidth%2;
		m_OverlayCtxt.uiDstOffsetX = m_OverlayCtxt.uiDstOffsetX-m_OverlayCtxt.uiDstOffsetX%2;

		if (m_OverlayCtxt.uiSrcWidth < 2) m_OverlayCtxt.uiSrcWidth = 2;
		if (m_OverlayCtxt.uiSrcHeight < 2) m_OverlayCtxt.uiSrcHeight = 2;
		if (m_OverlayCtxt.uiDstWidth < 2) m_OverlayCtxt.uiDstWidth = 2;
		break;
	}

	// Adjust for Overlay Window Position
	if (m_OverlayCtxt.uiDstWidth+m_OverlayCtxt.uiDstOffsetX > (unsigned int)m_dwDeviceScreenWidth)
	{
		//m_OverlayCtxt.uiDstWidth = m_dwDeviceScreenWidth - m_OverlayCtxt.uiDstOffsetX;	// Adjust Width
		m_OverlayCtxt.uiDstOffsetX = m_dwDeviceScreenWidth - m_OverlayCtxt.uiDstWidth;		// Adjust Offset
	}

	if (m_OverlayCtxt.uiDstHeight+m_OverlayCtxt.uiDstOffsetY  > (unsigned int)m_dwDeviceScreenHeight)
	{
		//m_OverlayCtxt.uiDstHeight = m_dwDeviceScreenHeight - m_OverlayCtxt.uiDstOffsetY;	// Adjust Height
		m_OverlayCtxt.uiDstOffsetY  = m_dwDeviceScreenHeight - m_OverlayCtxt.uiDstHeight;	// Adjust Offset
	}

	// After 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));

	if (m_VideoPowerState == VideoPowerOff)
	{
		// To Avoid System Hang in SystemIdle State
		// When Application access to DDraw API in SystemIdle State
		// System Hangs... (Maybe Display Driver in VideoPowerOff state)
		DISPDRV_INF((_T("[DISPDRV:INF] OverlayInitialize() : Skipped in 'VideoPowerOff State'\n\r")));
	}
	else
	{
		DevOverlayInitialize();
	}

	LeaveCriticalSection(&m_csDevice);
}


void
S3C6400Disp::OverlaySetPosition(UINT32 uiOffsetX, UINT32 uiOffsetY)
{
	DISPDRV_INF((_T("OverlaySetPosition() (%d,%d)\n\r"), uiOffsetX, uiOffsetY));

	EnterCriticalSection(&m_csDevice);

	m_OverlayCtxt.uiDstOffsetX = uiOffsetX;
	m_OverlayCtxt.uiDstOffsetY  = uiOffsetY;

	// Before Adjust Offset
	//DISPDRV_ERR((_T("SetPostion [%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));

	// Adjust for Post Processor and FIMD restriction
	if (m_OverlayCtxt.pSurface->PixelFormat() == ddgpePixelFormat_565)
	{
		m_OverlayCtxt.uiDstOffsetX = m_OverlayCtxt.uiDstOffsetX-m_OverlayCtxt.uiDstOffsetX%2;
	}

	// Adjust for Overlay Window Position
	if (m_OverlayCtxt.uiDstWidth+m_OverlayCtxt.uiDstOffsetX > (unsigned int)m_dwDeviceScreenWidth)
	{
		//m_OverlayCtxt.uiDstWidth = m_dwDeviceScreenWidth - m_OverlayCtxt.uiDstOffsetX;	// Adjust Width
		m_OverlayCtxt.uiDstOffsetX = m_dwDeviceScreenWidth - m_OverlayCtxt.uiDstWidth;		// Adjust Offset
	}

	if (m_OverlayCtxt.uiDstHeight+m_OverlayCtxt.uiDstOffsetY  > (unsigned int)m_dwDeviceScreenHeight)
	{
		//m_OverlayCtxt.uiDstHeight = m_dwDeviceScreenHeight - m_OverlayCtxt.uiDstOffsetY;	// Adjust Height
		m_OverlayCtxt.uiDstOffsetY  = m_dwDeviceScreenHeight - m_OverlayCtxt.uiDstHeight;	// Adjust Offset
	}

	// After Adjust Offset
	//DISPDRV_ERR((_T("SetPostion [%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));

	if (m_VideoPowerState == VideoPowerOff)
	{
		// To Avoid System Hang in SystemIdle State
		// When Application access to DDraw API in SystemIdle State
		// System Hangs... (Maybe Display Driver in VideoPowerOff state)
		DISPDRV_INF((_T("[DISPDRV:INF] OverlaySetPosition() : Skipped in 'VideoPowerOff State'\n\r")));
	}
	else
	{
		DevOverlaySetPosition();
	}