s3c2450disp.cpp

这是S3C2416平台上面显示驱动的代码

			{
				bAnd = andPtr[row * pMask->Stride() + col];
				bXor = xorPtr[row * pMask->Stride() + col];

				for (bitMask = 0x0080, i = 0; i < 8; bitMask >>= 1, i++)
				{
					andLine[(col * 8) + i] = bAnd & bitMask ? 0xFF : 0x00;
					xorLine[(col * 8) + i] = bXor & bitMask ? 0xFF : 0x00;
				}
			}
		}
	}

    return    S_OK;
}

SCODE    S3C2450DISP::MovePointer(INT xPosition, INT yPosition)
{
	CursorOff( );

	if (xPosition != -1 || yPosition != -1)
	{
		// compute new cursor rect
		m_CursorRect.left = xPosition - m_CursorHotspot.x;
		m_CursorRect.right = m_CursorRect.left + m_CursorSize.x;
		m_CursorRect.top = yPosition - m_CursorHotspot.y;
		m_CursorRect.bottom = m_CursorRect.top + m_CursorSize.y;

		CursorOn( );
	}

	return    S_OK;
}

void  S3C2450DISP::WaitForNotBusy(void)
{
	m_oG2D->WaitForIdle( );	//< Wait for Fully Empty Command Fifo for all BitBlt request
	return;
}

int  S3C2450DISP::IsBusy(void)
{
	return    0;
}

void    S3C2450DISP::GetPhysicalVideoMemory(unsigned long *physicalMemoryBase, unsigned long *videoMemorySize)
{
	RETAILMSG (jj, (TEXT("S3C2450DISP::GetPhysicalVideoMemory\r\n")));    

	*physicalMemoryBase = m_pvFlatFrameBuffer;
	*videoMemorySize = m_cbScanLineLength * m_cyPhysicalScreen;
}

void
S3C2450DISP::GetVirtualVideoMemory(
    unsigned long *virtualMemoryBase,
    unsigned long *videoMemorySize
    )
{
	RETAILMSG (jj, (TEXT("S3C2450DISP::GetVirtualVideoMemory\r\n")));    

	*virtualMemoryBase = m_VirtualFrameBuffer;
	*videoMemorySize = 0x100000;
}

INT  S3C2450DISP::InVBlank(void)
{
	static    BOOL    value = FALSE;

	value = !value;
	return value;
}

SCODE    S3C2450DISP::SetPalette(const PALETTEENTRY *source, USHORT firstEntry, USHORT numEntries)
{

	if (firstEntry < 0 || firstEntry + numEntries > 256 || source == NULL)
	{
		return    E_INVALIDARG;
	}

	return    S_OK;
}

VIDEO_POWER_STATE
PmToVideoPowerState(CEDEVICE_POWER_STATE pmDx)
{
	VIDEO_POWER_STATE vps;
	RETAILMSG(jj,(_T("++PmToVideoPowerState\r\n")));

	switch(pmDx) {
		case D0:        // turn the display on
			vps = VideoPowerOn;
			break;
		case D1:        // if asked for a state we don't support, go to the next lower one
		case D2:
		case D3:
		case D4:
			vps = VideoPowerOff;
			break;
		default:
			RETAILMSG(jj , (L"PmToVideoPowerState: mapping unknown PM state %d to VideoPowerOn\r\n", pmDx));
			vps = VideoPowerOn;
			break;
	}

	return vps;
}

// this routine maps video power states to PM power states.
CEDEVICE_POWER_STATE
VideoToPmPowerState(VIDEO_POWER_STATE vps)
{
	CEDEVICE_POWER_STATE pmDx;
	
	RETAILMSG(jj,(_T("++VideoToPmPowerState\r\n")));

	switch(vps)
	{
		case VideoPowerOn:
			pmDx = D0;
			break;
		case VideoPowerStandBy:
			pmDx = D1;
			break;
		case VideoPowerSuspend:
			pmDx = (CEDEVICE_POWER_STATE)D2;
			break;
		case VideoPowerOff:
			pmDx = (CEDEVICE_POWER_STATE)D4;
			break;
		default:
			pmDx = D0;
			RETAILMSG(jj, (L"VideoToPmPowerState: mapping unknown video state %d to pm state %d\r\n", vps, pmDx));
			break;
	}

	return pmDx;
}

#define ESC_SUCCESS             0x00000001
#define ESC_FAILED               0xFFFFFFFF
#define ESC_NOT_SUPPORTED      0x00000000


ULONG
S3C2450DISP::DrvEscape(
    SURFOBJ * pso,
    ULONG     iEsc,
    ULONG     cjIn,
    void    * pvIn,
    ULONG     cjOut,
    void    * pvOut
    )
{
	ULONG Result = 0;	
	if (iEsc == QUERYESCSUPPORT)
	{
		if (*(DWORD*)pvIn == GETGXINFO
			|| *(DWORD*)pvIn == DRVESC_GETSCREENROTATION
			|| *(DWORD*)pvIn == DRVESC_SETSCREENROTATION
			|| *(DWORD*)pvIn == SETPOWERMANAGEMENT
			|| *(DWORD*)pvIn == GETPOWERMANAGEMENT
			|| *(DWORD*)pvIn == IOCTL_POWER_CAPABILITIES
			|| *(DWORD*)pvIn == IOCTL_POWER_QUERY
			|| *(DWORD*)pvIn == IOCTL_POWER_SET
			|| *(DWORD*)pvIn == IOCTL_POWER_GET  )
		{
			// The escape is supported.
			return 1;
		}
		else
		{
			// The escape isn't supported.
			return DispPerfQueryEsc(*(DWORD*)pvIn);;
		}

	}
	else if (iEsc == DRVESC_GETSCREENROTATION)
	{
		*(int *)pvOut = ((DMDO_0 | DMDO_90 | DMDO_180 | DMDO_270) << 8) | ((BYTE)m_iRotate);
		return DISP_CHANGE_SUCCESSFUL;
	}
	else if (iEsc == DRVESC_SETSCREENROTATION)
	{
		if ((cjIn == DMDO_0)   ||(cjIn == DMDO_90)  ||(cjIn == DMDO_180) ||(cjIn == DMDO_270)     )
		{
			return DynRotate(cjIn);
		}
		return DISP_CHANGE_BADMODE;
	}
	else if (iEsc == GETGXINFO)
	{
		return GetGameXInfo(iEsc, cjIn, pvIn, cjOut, pvOut);
	}
	else if (iEsc == SETPOWERMANAGEMENT)
	{
		if ((cjIn >= sizeof (VIDEO_POWER_MANAGEMENT)) && (pvIn != NULL))
		{
			PVIDEO_POWER_MANAGEMENT pvpm = (PVIDEO_POWER_MANAGEMENT)pvIn;

			if (pvpm->Length >= sizeof (VIDEO_POWER_MANAGEMENT))
			{
				switch (pvpm->PowerState)
				{
					case VideoPowerStandBy:
					case VideoPowerOn:
						SetDisplayPower(VideoPowerOn);
						Result = ESC_SUCCESS;
						break;
					case VideoPowerOff:
					case VideoPowerSuspend:
						SetDisplayPower(VideoPowerOff);
						Result = ESC_SUCCESS;
					break;
				}
			}
		}
		
		if (Result != ESC_SUCCESS)
		{
			// Shouldn't get here if everything was ok.
			SetLastError(ERROR_INVALID_PARAMETER);
			Result = ESC_FAILED;
		}
		return Result;
	}
	else if (iEsc == GETPOWERMANAGEMENT)
	{
		RETAILMSG(jj, (L"GETPOWERMANAGEMENT\n"));
		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
		{
			// Shouldn't get here if everything was ok.
			SetLastError(ERROR_INVALID_PARAMETER);
			Result = ESC_FAILED;
		}
		return Result;
	}
	else if (iEsc == IOCTL_POWER_CAPABILITIES)
	{
		// 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;	// support D0 and D4
				Result = ESC_SUCCESS;
			}
			__except(EXCEPTION_EXECUTE_HANDLER)
			{
				RETAILMSG(jj, (L"%s: exception in ioctl1\r\n"));
			}
		}
		return Result;
	}
	else if(iEsc == IOCTL_POWER_QUERY)
	{
		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;
				}
			}
			__except(EXCEPTION_EXECUTE_HANDLER)
			{
				RETAILMSG(jj, (L"%s: exception in ioctl2\r\n"));
			}
		}
		return Result;
	}
	else if(iEsc == IOCTL_POWER_SET)	
	{		
		if(pvOut != NULL && cjOut == sizeof(CEDEVICE_POWER_STATE))
		{
			__try
			{
				CEDEVICE_POWER_STATE NewDx = *(PCEDEVICE_POWER_STATE) pvOut;
				CEDEVICE_POWER_STATE CurrentDx;
				
				if(VALID_DX(NewDx))
				{
					VIDEO_POWER_STATE ulPowerState = PmToVideoPowerState(NewDx);
					SetDisplayPower(ulPowerState);
					CurrentDx = VideoToPmPowerState((VIDEO_POWER_STATE)m_VideoPowerState);
					Result = ESC_SUCCESS;
				}
				else{   }
			}
			__except(EXCEPTION_EXECUTE_HANDLER)
			{
				RETAILMSG(jj, (L"%s: exception in ioctl3\r\n"));
			}
		}
		return Result;
	}
	else if(iEsc == IOCTL_POWER_GET)
	{
		if(pvOut != NULL && cjOut == sizeof(CEDEVICE_POWER_STATE))
		{
			__try
			{
				CEDEVICE_POWER_STATE CurrentDx = D0;//VideoToPmPowerState((VIDEO_POWER_STATE)m_VideoPowerState);
				*(PCEDEVICE_POWER_STATE) pvOut = D0; //CurrentDx;
				Result = ESC_SUCCESS;
			}
			__except(EXCEPTION_EXECUTE_HANDLER)
			{
				RETAILMSG(jj, (L"%s: exception in ioctl4\r\n"));
			}
		}
		return Result;
	}
	else 
	{
		return DispPerfDrvEscape(iEsc, cjIn, pvIn, cjOut,pvOut);
	}
}

#undef ESC_NOT_SUPPORTED
#undef ESC_FAILED
#undef ESC_SUCCESS

void S3C2450DISP::SetDisplayPower(ULONG PowerState)
{
	static BYTE * pVideoMemory = NULL;

	RETAILMSG(jj,(_T("++SetDisplayPower\r\n")));

	// If we're already in the appropriate state, just return 
	if (m_VideoPowerState == PowerState)
	{
		return;
	}

	if (PowerState == VideoPowerOff)
	{
		RETAILMSG(jj,(TEXT("VideoPowerOff\n")));
		m_VideoPowerState = VideoPowerOff;
		m_pLCDReg->WIN0MAP |= 1<<24;
		m_pLCDReg->WIN1MAP |= 1<<24;
		Sleep(100);
	}
	else
	{
		RETAILMSG(jj,(TEXT("VideoPowerOn\n")));
		m_VideoPowerState = VideoPowerOn;
		m_pLCDReg->WIN0MAP &= ~(1<<24);
		m_pLCDReg->WIN1MAP &= ~(1<<24);
	}
}

int
S3C2450DISP::GetRotateModeFromReg()
{
	HKEY hKey;

	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:
					return DMDO_0;
				case 90:
					return DMDO_90;
				case 180:
					return DMDO_180;
				case 270:
					return DMDO_270;
				default:
					return DMDO_0;
			}
		}

		RegCloseKey(hKey);
	}

	return DMDO_0;
}

void
S3C2450DISP::SetRotateParams()
{
	int iswap;

	switch(m_iRotate)
	{
		case DMDO_0:
			m_nScreenHeightSave = m_nScreenHeight;
			m_nScreenWidthSave  = m_nScreenWidth;
			break;
		case DMDO_180:
			m_nScreenHeightSave = m_nScreenHeight;
			m_nScreenWidthSave  = m_nScreenWidth;
			break;
		case DMDO_90:
		case DMDO_270:
			iswap               = m_nScreenHeight;
			m_nScreenHeight     = m_nScreenWidth;
			m_nScreenWidth      = iswap;
			m_nScreenHeightSave = m_nScreenWidth;
			m_nScreenWidthSave  = m_nScreenHeight;
			break;
		default:
			m_nScreenHeightSave = m_nScreenHeight;
			m_nScreenWidthSave  = m_nScreenWidth;
			break;
	}

	return;
}


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

	// DirectDraw and rotation can't co-exist.
	if (m_InDDraw)
	{
		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(  );

	return DISP_CHANGE_SUCCESSFUL;
}

void S3C2450DISP::EnableInterrupt()
{
	m_pLCDReg->VIDINTCON |= (0x1<<12)|(0x1<<0);	/// Video Frame Disalbe
}

void S3C2450DISP::DisableInterrupt()
{
	m_pLCDReg->VIDINTCON &= ~((0x1<<12)|(0x1<<0));	/// Video Frame Disalbe
}


ULONG *
APIENTRY
DrvGetMasks(
    DHPDEV dhpdev
    )
{
	return gBitMasks;
}