s3c6400_disp.cpp

Samsung公司S3C6400芯片的BSP源码包

					break;
				}
#endif
				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_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 s3c6400_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] --S3C6400Disp::DrvEscape()\n\r")));

	return 0;
}

int
S3C6400Disp::GetRotateModeFromReg()
{
	HKEY hKey;
	int iRet = DMDO_0;

	DISPDRV_MSG((_T("[DISPDRV] ++S3C6400Disp::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)
			{
			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;
			}
		}

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

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

	return iRet;
}

void
S3C6400Disp::SetRotateParams()
{
	DISPDRV_MSG((_T("[DISPDRV:INF] S3C6400Disp::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
S3C6400Disp::DynRotate(int angle)
{
	GPESurfRotate * pSurf = (GPESurfRotate *)m_pPrimarySurface;

	DISPDRV_MSG((_T("[DISPDRV] ++S3C6400Disp::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] --S3C6400Disp::DynRotate()\n\r")));

	return DISP_CHANGE_SUCCESSFUL;
}


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

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

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

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

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

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

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

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

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

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

	m_hVideoMemoryMapping = CreateFileMapping(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0, m_VideoMemorySize, NULL);
	if (m_hVideoMemoryMapping == NULL)
	{
		DISPDRV_ERR((_T("[DISPDRV:ERR] AllocResource() : CreateFileMapping() Failed \n\r")));
		return FALSE;
	}
	else
	{
		m_VideoMemoryVirtualBase = (DWORD)MapViewOfFile(m_hVideoMemoryMapping, FILE_MAP_WRITE, 0, 0, 0);
	}

	if (VirtualCopy((void *)m_VideoMemoryVirtualBase, (void *)(m_VideoMemoryPhysicalBase>>8), m_VideoMemorySize, PAGE_READWRITE | PAGE_NOCACHE | PAGE_PHYSICAL))
	{
		CeSetMemoryAttributes((void *)m_VideoMemoryVirtualBase, (void *)(m_VideoMemoryPhysicalBase>>8), m_VideoMemorySize, PAGE_WRITECOMBINE);
	}
	else
	{
		DISPDRV_ERR((_T("[DISPDRV:ERR] AllocResource() : m_VideoMemoryVirtualBase VirtualCopy() Failed \n\r")));
		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));

#if	1	// To use power control driver
	// Open Device Power Control Driver
	m_hPowerControl = CreateFile( L"PWC0:", GENERIC_READ|GENERIC_WRITE, FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, 0);
	if (m_hPowerControl == INVALID_HANDLE_VALUE)
	{
		DISPDRV_ERR((_T("[DISPDRV:ERR] AllocResource() : PWC0 Open Device Failed\n\r")));
		return FALSE;
	}
#endif

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

	return TRUE;
}


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

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

	if (m_VideoMemoryVirtualBase != NULL)
	{
		UnmapViewOfFile((LPVOID)m_VideoMemoryVirtualBase);
	}

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

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

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

	if (m_pSysConReg != NULL)
	{
		DrvLib_UnmapIoSpace((PVOID)m_pSysConReg);
		m_pSysConReg = 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;
	}

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

	if (m_pTVEncReg != NULL)
	{
		DrvLib_UnmapIoSpace((PVOID)m_pTVEncReg);