s3c6410_disp.cpp

SAMSUNG S3C6410 CPU BSP for winmobile6

		return GetGameXInfo(iEsc, cjIn, pvIn, cjOut, pvOut);
	}
	else if (iEsc == GETRAWFRAMEBUFFER)
	{
		DISPDRV_MSG((_T("[DISPDRV] DrvEscape() : GETRAWFRAMEBUFFER\n\r")));

		return GetRawFrameBuffer(iEsc, cjIn, pvIn, cjOut, pvOut);
	}
	else if (iEsc == SETPOWERMANAGEMENT)
	{
		DISPDRV_MSG((_T("[DISPDRV] DrvEscape() : SETPOWERMANAGEMENT\n\r")));

		if ((cjIn >= sizeof (VIDEO_POWER_MANAGEMENT)) && (pvIn != NULL))
		{
			PVIDEO_POWER_MANAGEMENT pvpm = (PVIDEO_POWER_MANAGEMENT)pvIn;

			if (pvpm->Length >= sizeof (VIDEO_POWER_MANAGEMENT))
			{
				SetDisplayPowerState((VIDEO_POWER_STATE)(pvpm->PowerState));
			}
		}

		if (Result != ESC_SUCCESS)
		{
			DISPDRV_ERR((_T("[DISPDRV:ERR] DrvEscape() : SETPOWERMANAGEMENT Fail\n\r")));

			// Shouldn't get here if everything was ok.
			SetLastError(ERROR_INVALID_PARAMETER);
			Result = ESC_FAILED;
		}

		return Result;
	}
	else if (iEsc == GETPOWERMANAGEMENT)
	{
		DISPDRV_MSG((_T("[DISPDRV] DrvEscape() : GETPOWERMANAGEMENT\n\r")));

		if ((cjOut >= sizeof (VIDEO_POWER_MANAGEMENT)) && (pvOut != NULL))
		{
			PVIDEO_POWER_MANAGEMENT pvpm = (PVIDEO_POWER_MANAGEMENT)pvOut;

			pvpm->Length = sizeof (VIDEO_POWER_MANAGEMENT);
			pvpm->DPMSVersion = 0;

			pvpm->PowerState = m_VideoPowerState;

			Result = ESC_SUCCESS;
		}
		else
		{
			DISPDRV_ERR((_T("[DISPDRV:ERR] DrvEscape() : GETPOWERMANAGEMENT Fail\n\r")));

			// Shouldn't get here if everything was ok.
			SetLastError(ERROR_INVALID_PARAMETER);
			Result = ESC_FAILED;
		}

		return Result;
	}
	else if (iEsc == IOCTL_POWER_CAPABILITIES)
	{
		DISPDRV_MSG((_T("[DISPDRV] DrvEscape() : IOCTL_POWER_CAPABILITIES\n\r")));

		// tell the power manager about ourselves
		if (pvOut != NULL && cjOut == sizeof(POWER_CAPABILITIES))
		{
			__try
			{
				PPOWER_CAPABILITIES ppc = (PPOWER_CAPABILITIES) pvOut;
				memset(ppc, 0, sizeof(*ppc));
				ppc->DeviceDx = 0x11;	// Supports D0 and D4	// 0x1D;	// (1 1101) support D0, D1, D2, and D4
				Result = ESC_SUCCESS;
			}
			__except(EXCEPTION_EXECUTE_HANDLER)
			{
				DISPDRV_ERR((_T("[DISPDRV:ERR] DrvEscape() : IOCTL_POWER_CAPABILITIES Exception Occurs\n\r")));
			}
		}

		return Result;
	}
	else if(iEsc == IOCTL_POWER_QUERY)
	{
		DISPDRV_MSG((_T("[DISPDRV] DrvEscape() : IOCTL_POWER_QUERY\n\r")));

		if(pvOut != NULL && cjOut == sizeof(CEDEVICE_POWER_STATE))
		{
			// return a good status on any valid query, since we are always ready to
			// change power states.
			__try
			{
				CEDEVICE_POWER_STATE NewDx = *(PCEDEVICE_POWER_STATE) pvOut;
				if(VALID_DX(NewDx))
				{
					// this is a valid Dx state so return a good status
					Result = ESC_SUCCESS;
				}
				else
				{
					DISPDRV_ERR((_T("[DISPDRV:ERR] DrvEscape() : IOCTL_POWER_QUERY Fail\n\r")));
				}
			}
			__except(EXCEPTION_EXECUTE_HANDLER)
			{
				DISPDRV_ERR((_T("[DISPDRV:ERR] DrvEscape() : IOCTL_POWER_QUERY Exception Occurs\n\r")));
			}
		}

		return Result;
	}
	else if(iEsc == IOCTL_POWER_SET)
	{
		DISPDRV_MSG((_T("[DISPDRV] DrvEscape() : IOCTL_POWER_SET\n\r")));

		if(pvOut != NULL && cjOut == sizeof(CEDEVICE_POWER_STATE))
		{
			__try
			{
				CEDEVICE_POWER_STATE NewDx = *(PCEDEVICE_POWER_STATE) pvOut;
				if(VALID_DX(NewDx))
				{
					DISPDRV_INF((_T("[DISPDRV] DrvEscape() : IOCTL_POWER_SET(D%d)\n\r"), NewDx));
					SetDisplayPowerState(PmToVideoPowerState(NewDx));
					Result = ESC_SUCCESS;
				}
				else
				{
					DISPDRV_ERR((_T("[DISPDRV:ERR] DrvEscape() : IOCTL_POWER_SET Fail\n\r")));
				}
			}
			__except(EXCEPTION_EXECUTE_HANDLER)
			{
				DISPDRV_ERR((_T("[DISPDRV:ERR] DrvEscape() : IOCTL_POWER_SET Exception Occurs\n\r")));
			}
		}

		return Result;
	}
	else if(iEsc == IOCTL_POWER_GET)
	{
		DISPDRV_MSG((_T("[DISPDRV] DrvEscape() : IOCTL_POWER_GET\n\r")));

		if(pvOut != NULL && cjOut == sizeof(CEDEVICE_POWER_STATE))
		{
			__try
			{
				*(PCEDEVICE_POWER_STATE) pvOut = VideoToPmPowerState(GetDisplayPowerState());

				Result = ESC_SUCCESS;
			}
			__except(EXCEPTION_EXECUTE_HANDLER)
			{
				DISPDRV_ERR((_T("[DISPDRV:ERR] DrvEscape() : IOCTL_POWER_GET Exception Occurs\n\r")));
			}
		}

		return Result;
	}
	else if(iEsc == DRVESC_OUTPUT_RGB)
	{
		if (DevChangeOutputInterface(OUTPUT_IF_RGB))
		{
			return ESC_SUCCESS;
		}
		else
		{
			return ESC_FAILED;
		}
	}
	else if(iEsc == DRVESC_OUTPUT_TV)
	{
		if (DevChangeOutputInterface(OUTPUT_IF_TV))
		{
			return ESC_SUCCESS;
		}
		else
		{
			return ESC_FAILED;
		}
	}
	else if (iEsc == DRVESC_OUTPUT_SWITCH)
	{
		if (m_eOutputInterface == OUTPUT_IF_RGB)
		{
			if (DevChangeOutputInterface(OUTPUT_IF_TV))
			{
				return ESC_SUCCESS;
			}
			else
			{
				return ESC_FAILED;
			}
		}
		else
		{
			if (DevChangeOutputInterface(OUTPUT_IF_RGB))
			{
				return ESC_SUCCESS;
			}
			else
			{
				return ESC_FAILED;
			}
		}
	}
	else if(iEsc == DRVESC_TV_DMA_DISABLE)
	{
		// TODO: We need to implement wrapper OutputDisableTVDMA()...
		EnterCriticalSection(&m_csDevice);
		DevOutputDisableTVDMA();
		m_eTVDMAMode = TV_DMA_DISABLE;
		TVOutReleaseResource();
		LeaveCriticalSection(&m_csDevice);

		return ESC_SUCCESS;
	}
	else if(iEsc == DRVESC_TV_DMA_PRIMARY)
	{
		if (TVOutAllocResource())
		{
			EnterCriticalSection(&m_csDevice);
			DevSetTVDMAMode(TV_DMA_PRIMARY);
			LeaveCriticalSection(&m_csDevice);

			return ESC_SUCCESS;
		}
		else
		{
			return ESC_FAILED;
		}
	}
	else if(iEsc == DRVESC_TV_DMA_OVERLAY)
	{
		if (TVOutAllocResource())
		{
			EnterCriticalSection(&m_csDevice);
			DevSetTVDMAMode(TV_DMA_OVERLAY);
			LeaveCriticalSection(&m_csDevice);

			return ESC_SUCCESS;
		}
		else
		{
			return ESC_FAILED;
		}
	}

	else if(iEsc == DRVESC_G2D_ACCEL)
	{
		DISPDRV_MSG((_T("[DISPDRV] DrvEscape() : DRVESC_G2D_ACCEL\n\r")));
		/// Control Accelerator On/Off
		/// Adjust Acceleration Level
		///		Off:0
		///		Min:1   Only BitBlt
		///		Normal:2	Only Line
		///		Full:3		Line + FillRect
		/// Only 1 Word Control Code
		/// Return Value : Acceleration Level
		///		Succeed : Accerleration Level ( 1 ~ 3 )
		///		Fail : 0 (default no accleration)
		return Result;
	}
	else if(iEsc == DRVESC_G2D_PROFILE)
	{
		/// Control Profiler
		/// cjIn : sizeof(G2D_PROFILE_CTRL)
		/// pvIn : Control Operation
		/// cjOut : sizeof(G2D_PROFILE_DATA)
		/// pvOut : Profiled Data
		/// Related Structure (refer s3c6410_disp.h)
		///  struct G2D_PROFILE_CTRL;
		///  struct G2D_PROFILE_DATA;
		/// Return Value :
		return Result;
	}
#if DO_DISPPERF
	else
	{
		return DispPerfDrvEscape(iEsc, cjIn, pvIn, cjOut,pvOut);
	}
#endif
	//DISPDRV_MSG((_T("[DISPDRV] --S3C6410Disp::DrvEscape()\n\r")));

	return 0;
}


/**
 *	Application Set GDI rotation 0 degree as Portrait.
 *	So, If Native LANDSCAPE LCD panel is used.
 *  We must Rotate This value.
 *
 */
int
S3C6410Disp::GetRotateModeFromReg()
{
	HKEY hKey;
#if (LCD_TYPE == LCD_TYPE_PORTRAIT)
	int iRet = DMDO_0;
#elif (LCD_TYPE == LCD_TYPE_LANDSCAPE)
	int iRet = DMDO_90;	
#else
#error 	LCD_TYPE_UNDEFINED_ERROR
#endif

	DISPDRV_MSG((_T("[DISPDRV] ++S3C6410Disp::GetRotateModeFromReg()\n\r")));

	if (ERROR_SUCCESS == RegOpenKeyEx(HKEY_LOCAL_MACHINE, TEXT("SYSTEM\\GDI\\ROTATION"), 0, 0, &hKey))
	{
		DWORD dwSize, dwAngle, dwType = REG_DWORD;

		dwSize = sizeof(DWORD);
		if (ERROR_SUCCESS == RegQueryValueEx(hKey, TEXT("ANGLE"), NULL, &dwType, (LPBYTE)&dwAngle, &dwSize))
		{
			switch (dwAngle)
			{
#if (LCD_TYPE == LCD_TYPE_PORTRAIT)
			case 0:
				iRet = DMDO_0;
				break;

			case 90:
				iRet = DMDO_90;
				break;

			case 180:
				iRet = DMDO_180;
				break;

			case 270:
				iRet = DMDO_270;
				break;

			default:
				iRet = DMDO_0;
				break;
#elif (LCD_TYPE == LCD_TYPE_LANDSCAPE)				
			case 0:
				iRet = DMDO_270;
				break;

			case 90:
				iRet = DMDO_0;
				break;

			case 180:
				iRet = DMDO_90;
				break;

			case 270:
				iRet = DMDO_180;
				break;

			default:	/// Default Portrait. Logically DMDO_0
				iRet = DMDO_270;
				break;
#else
#error 	LCD_TYPE_UNDEFINED_ERROR
#endif
			}
		}

		RegCloseKey(hKey);
	}
	else
	{
		DISPDRV_ERR((_T("[DISPDRV:ERR] GetRotateModeFromReg() : RegOpenKeyEx() Fail\n\r")));
	}

	DISPDRV_MSG((_T("[DISPDRV] --S3C6410Disp::GetRotateModeFromReg() = %d\n\r"), iRet));

	return iRet;
}

void
S3C6410Disp::SetRotateParams()
{
	DISPDRV_MSG((_T("[DISPDRV:INF] S3C6410Disp::SetRotateParams() : Angle = %d\n\r"), m_iRotate));

	switch(m_iRotate)
	{
	case DMDO_90:
	case DMDO_270:
		m_nScreenHeight = m_nScreenWidthSave;
		m_nScreenWidth = m_nScreenHeightSave;
		break;

	case DMDO_0:
	case DMDO_180:
	default:
		m_nScreenWidth = m_nScreenWidthSave;
		m_nScreenHeight = m_nScreenHeightSave;
		break;
	}

	return;
}

LONG
S3C6410Disp::DynRotate(int angle)
{
	GPESurfRotate * pSurf = (GPESurfRotate *)m_pPrimarySurface;

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

	// DirectDraw and rotation can't co-exist.
	if (m_InDDraw)
	{
		DISPDRV_ERR((_T("[DISPDRV:ERR] DynRotate() : Can NOT Rotate in DirectDraw Mode\n\r")));
		return DISP_CHANGE_BADMODE;
	}

	CursorOff();

	m_iRotate = angle;

	switch(m_iRotate)
	{
	case DMDO_0:
	case DMDO_180:
		m_nScreenHeight = m_nScreenHeightSave;
		m_nScreenWidth  = m_nScreenWidthSave;
		break;

	case DMDO_90:
	case DMDO_270:
		m_nScreenHeight = m_nScreenWidthSave;
		m_nScreenWidth  = m_nScreenHeightSave;
		break;
	}

	m_pMode->width  = m_nScreenWidth;
	m_pMode->height = m_nScreenHeight;

	pSurf->SetRotation(m_nScreenWidth, m_nScreenHeight, angle);

	CursorOn();

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

	return DISP_CHANGE_SUCCESSFUL;
}


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

	DWORD dwBytes;

	m_pDispConReg = (S3C6410_DISPLAY_REG *)DrvLib_MapIoSpace(S3C6410_BASE_REG_PA_DISPLAY, sizeof(S3C6410_DISPLAY_REG), FALSE);
	if (m_pDispConReg == NULL)
	{
		DISPDRV_ERR((_T("[DISPDRV:ERR] AllocResource() : m_pDispConReg DrvLib_MapIoSpace() Failed \n\r")));
		return FALSE;
	}

	m_pGPIOReg = (S3C6410_GPIO_REG *)DrvLib_MapIoSpace(S3C6410_BASE_REG_PA_GPIO, sizeof(S3C6410_GPIO_REG), FALSE);
	if (m_pGPIOReg == NULL)
	{
		DISPDRV_ERR((_T("[DISPDRV:ERR] AllocResource() : m_pGPIOReg DrvLib_MapIoSpace() Failed \n\r")));
		return FALSE;
	}

	m_pSPIReg = (S3C6410_SPI_REG *)DrvLib_MapIoSpace(S3C6410_BASE_REG_PA_SPI0, sizeof(S3C6410_SPI_REG), FALSE);
	if (m_pSPIReg == NULL)
	{
		DISPDRV_ERR((_T("[DISPDRV:ERR] AllocResource() : m_pSPIReg DrvLib_MapIoSpace() Failed \n\r")));
		return FALSE;
	}

	// Open Video Engine Driver
	m_hVideoDrv = CreateFile( L"VDE0:", GENERIC_READ|GENERIC_WRITE, FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, 0);
	if (m_hVideoDrv == INVALID_HANDLE_VALUE)
	{
		DISPDRV_ERR((_T("[DISPDRV:ERR] AllocResource() : VDE0 Open Device Failed\n\r")));
		return FALSE;
	}